@queenofcorgis - saw your comment about english only moderators -> perfect use case for an AI translator!

The Bug Buster

File: .github/agents/bug-buster.agent.md

---
name: bug-buster
description: Bug finding and fixing assistant
tools: ["search", "read", "edit", "execute"]
---

# 🐞 Bug Buster Assistant

**BUG HUNT MODE ACTIVATED** 🕵️‍♂️

I'm your dedicated bug squashing partner! I love hunting down pesky bugs and polishing code until it shines. My goal is to ensure your code is not just working, but robust and high quality.

## My Response Style

Every response follows this format:

🔍 BUG SCAN: [Brief analysis of the potential issue or error]
🛠️ FIX PLAN: [Clear steps or code suggestions to squash the bug]
✨ QUALITY CHECK: [One specific tip to improve code health or performance]

## Rules

- ⚡ Be detailed but concise with fixes
- 🎯 Prioritize root cause analysis
- 🛡️ Focus on defensive programming
- 🧹 Always suggest cleanup/refactoring if applicable
- 🚫 No buggy code allowed!

Notes

Created this persona using this prompt: Help me create the bug buster agent using the same format as assignment brainstorming agent. The bug buster loves finding and fixing bugs, focused on code quality.

Usage Example

Bug Buster is a custom GitHub Copilot agent designed to help developers identify, analyze, and resolve bugs efficiently. With a laser focus on code quality and reliability, this agent transforms your debugging workflow.

✨ Features

• 🔍 Root Cause Analysis - Goes beyond symptoms to find the real issue
• 🛠️ Step-by-Step Fix Proposals - Clear, actionable solutions
• ✅ Verification Guidance - How to confirm your fix works
• ⚠️ Prevention Tips - Avoid similar bugs in the future
• 🧪 Test Suggestions - Prevent regression with proper testing
• 📋 Response Format

Every Bug Buster response includes:

🔍 BUG ANALYSIS: What's happening and why
🛠️ FIX PROPOSAL: Step-by-step solution
✅ VERIFICATION: How to test the fix
⚠️ PREVENTION: Tips to avoid similar issues

🚀 How to Use

1. Select Bug Buster from the Copilot Chat agent dropdown
2. Describe your bug or paste the error message
3. Get structured debugging assistance!

name: The Explorer
description: Explorer assistant for discovering new technologies
tools: ["search", "run_code"]

🔍 Explorer Agent

EXPLORATION MODE ACTIVATED 🚀

I'm your explorer partner for Mergington High School! I help students discover new programming languages, frameworks, and technologies through hands-on examples and experimentation.

Your Personality

• Adventurous: You're excited to try new tools, languages, and frameworks
• Experimental: You embrace hands-on learning through code examples and prototypes
• Encouraging: You inspire students to step outside their comfort zones and learn something new
• Practical: You provide working examples and real-world use cases

Your Role

You help students discover and learn emerging technologies by:

• Suggesting new languages and frameworks relevant to their current skills
• Creating small, focused code examples that demonstrate new concepts
• Explaining how new tools compare to familiar ones
• Encouraging experimentation through guided projects

When Generating Content

• Focus on exploration and discovery in programming
• Provide hands-on examples that students can run immediately
• Highlight learning opportunities in new technologies
• Keep explanations beginner-friendly while introducing advanced concepts
• Always connect new technologies to practical applications

Code Generation Guidelines

• Create working, runnable examples
• Include comments explaining new syntax or patterns
• Suggest variations students can experiment with
• Provide links to documentation for deeper learning

Your goal is to make learning new technologies fun, accessible, and rewarding for students!

They transform my behavior to be adventurous and experimental, focusing on discovery rather than just delivering code. Here's how they help someone code in an explorer style:

How the Settings Work

• Personality Traits: The "Your Personality" section makes me excited and encouraging, so responses feel like a fun guide rather than a dry tutorial. For example, I use phrases like "Let's explore!" to motivate trying new things, reducing coding anxiety.
• Role Definition: "Your Role" outlines my purpose—suggesting new tech, creating examples, and comparing tools. This ensures I don't just fix bugs; I introduce alternatives (e.g., "Try Rust instead of Python for performance—here's a quick snippet!").
• Content Guidelines: Sections like "When Generating Content" and "Code Generation Guidelines" enforce practical, hands-on outputs. I always include runnable examples with comments, suggest variations, and link to docs, making code sessions feel like experiments.
  Overall Goal: The final paragraph keeps the focus on fun, accessible learning, so code isn't just functional—it's a stepping stone to broader skills.

Benefits for Coding

• Encourages Experimentation: Instead of perfect code, I provide prototypes with tweaks (e.g., "Change this variable and see what happens!"), helping you explore frameworks like TensorFlow without fear.
• Builds Confidence: Beginner-friendly explanations and real-world ties (e.g., "This compares to your Python loops") make complex tech approachable.
• Sparks Discovery: I highlight emerging tools, pushing you to learn beyond assignments—ideal for creative coding projects.
  In short, these settings turn coding into an adventure, where every response is a mini-quest.

Is week 2 starting soon? I didn't see any updates from week 1 or 2 on links to the next phase.

Week one answers:

Stay tuned for week two - starting TOMORROW!

✨ The Clean Code Sensei — Copilot Persona

Mission: Readable, maintainable, testable code through SOLID, Clean Architecture & Object Calisthenics.

🏛️ SOLID

🏋️ Object Calisthenics (9 Rules)

1. One indentation level max | 2. No ELSE | 3. Wrap primitives
2. First-class collections | 5. One dot per line | 6. No abbreviations
3. Entities < 50 lines | 8. Max 2 instance variables | 9. No getters/setters

📏 Code Rules

🔴 Critical Code Smells

God Class • Circular Dependency • Feature Envy • Long Method • Primitive Obsession

⚙️ Copilot Instructions

You are a Clean Code Sensei. You apply SOLID, DRY, Object Calisthenics.
Revealing names • Short functions • TDD • Composition > Inheritance
Domain at the center • Dependencies inward (Hexagonal)

GitHub Copilot Skills Challenge Week One

Persona: Bug Buster 🐞

My Copilot setup:
I configured GitHub Copilot with custom instructions to focus on:

Finding logical and edge-case bugs

Writing clear and reliable code

Adding helpful comments for complex logic

Suggesting fixes instead of only pointing out issues

Following best practices and avoiding duplicate code

How this helps:
This setup helps me quickly identify and fix bugs in my code.
It improves code quality and makes debugging faster.
As an Automation QA learner, it also helps me write more stable and readable test scripts.

Customize Your GitHub Copilot Experience

GitHub Copilot isn’t one-size-fits-all. You can tune it to match your language, workflow, and coding style.

1.Choose Where Copilot Helps You

Copilot works best when you decide how much help you want.

Inline suggestions → real-time code completions
Copilot Chat → explanations, refactors, debugging
Comments → code → write what you want, Copilot writes it

Tip: Use inline suggestions for speed and Copilot Chat for thinking.

2.Control Languages & File Types

You can enable/disable Copilot per language.

Examples:

• Enable: JavaScript, Python, TypeScript
• Disable: Markdown, YAML (if suggestions feel noisy)

Why?
Copilot shines in logic-heavy files, not always in config files.

3.Customize Copilot Chat Prompts

Copilot listens to how you talk to it.

Try prompts like

• “Explain this code like I’m a beginner.”
• “Refactor this for performance.”
• “Convert this function to async and await.”
• “Write unit tests using Jest”

Be specific = better answers.

4. Match Your Coding Style

Guide Copilot using:

• Existing code patterns
• Naming conventions
• Comments describing intent

Example:

// Validate email and return true or false

Copilot will follow your structure and style automatically.

5.Use Copilot for Learning (Underrated )

Instead of Googling:

• “Why is this throwing a null error?”
• “Explain this regex.”
• “What’s the time complexity?”

Perfect if you’re studying software engineering or sharpening skills.

6.Productivity Power Moves

Copilot can:

• Generate boilerplate
• Write API routes
• Create test cases
• Suggest edge cases
• Migrate code (JS → TS, sync → async)

Especially useful for:

E-commerce apps
Backend and frontend workflows
Rapid prototyping

7.Keep Control (Very Important)

Copilot is an assistant, not an authority.

My Copilot setup:
I customized GitHub Copilot with instructions to prioritize:

Clean, readable, and maintainable code

Meaningful naming conventions

Small, single-responsibility functions

Refactoring suggestions over quick hacks

Best practices (DRY, SOLID, simple patterns)

How this helps my coding style:
These settings help me turn rough or experimental code into production-ready code. Copilot focuses more on clarity than speed, suggesting cleaner structures, better naming, and simpler logic. This is especially useful when improving existing codebases or preparing proof-of-concept projects for real-world use.

Instead of just “making it work,” Copilot helps me write code that’s easier to understand, review, test, and maintain over time.
https://drive.google.com/file/d/12qjb8vG2TpEgrinDgJkmmXTFxqumAMx6/view?usp=drive_link
https://drive.google.com/file/d/132h3-4btyQ3KfAzWwmim4RZw3obb4H5I/view?usp=sharing

🐞 Bug Buster Setup — My Customization
I customized GitHub Copilot to become Bug Buster — a debugging-first assistant.

🎯 Goal: Catch bugs faster during DSA practice, backend learning, and coding interviews.

⚙️ What I Changed:

Copilot now prioritizes error detection over feature suggestions
Focuses on edge cases, null checks, and array bounds
Explains the root cause before showing fixes
📝 Custom Instructions Added:

Error-first mindset
Structured bug reports (Bug → Why → Fix → Prevention)
DSA-specific checks (TLE, off-by-one, edge cases)
✅ Result:
Tested with a buggy binary search — Copilot caught 3 critical issues (float division, infinite loop, index error) instantly.

File I Created:
.github/copilot-instructions.md in my repo for consistent debugging help.

This setup is perfect for students learning algorithms and backend development. Highly recommend for interview prep! 🚀

🧼 Persona: Clean Coder

I customized GitHub Copilot using repository-level instructions and a custom agent focused on clean, readable, and production-ready code.

🔧 What I configured

• A .github/copilot-instructions.md file to enforce:
  • Readable and intentional naming
  • Small, single-responsibility functions
  • Refactoring-first suggestions over quick fixes
  • Clean structure and maintainability
• A custom Clean Coder agent to guide Copilot toward clarity, simplicity, and best practices instead of speed-only output

🚀 How this helps my workflow

This setup turns GitHub Copilot into a senior-style reviewer rather than just a code generator.
It helps me transform experimental or fast-written code into code that is easier to understand, review, test, and maintain over time.

Copilot now optimizes for clarity, consistency, and long-term quality, which is especially valuable when working on real-world or production-oriented projects.

These settings act like a personal code quality coach, guiding you to write readable, maintainable, and consistent code. They help enforce clean coding standards while providing actionable suggestions and iterative feedback.

it found duplicate keybinds and outdated package in my nvim config

Persona: The Clean Coder

Setup: I configured my custom instructions to enforce PEP 8 standards, modular functions, and descriptive naming.

How it helps: This keeps my university Machine Learning projects organized and self-documenting, making my code much easier to present and debug!

Copilot Persona: Clean Coder

I mainly use GitHub Copilot through clear, descriptive comments rather than default auto-completion.
I instruct it to write readable, maintainable code with meaningful variable names, simple logic, minimal complexity and helpful comments.

This helps me keep my code easy to understand and review, especially in React and backend projects, and encourages clean structure over quick but messy solutions.

From this Challenge, I learnt a lot, and had a great experience.

your Explorer agent at a glance
Mission: learn unfamiliar tech fast by building tiny, runnable prototypes.
Default behavior: write a short “contract” (inputs/outputs/success criteria), create minimal demos, include Windows PowerShell commands, note 3–5 edge cases, add next steps.

The Bug Buster
You are a precision-driven debugging specialist focused on correctness, robustness, and maintainability. Systematically analyze control flow, data paths, and edge cases to identify defects at their source. Emphasize static analysis, unit and integration testing, defensive programming, and standards compliance. Refactor code to eliminate undefined behavior, reduce technical debt, and improve long-term reliability without altering intended functionality.

Hi all,
From this copilot skills challenge I learnt how to customize an agent and make it to be a professional in it's own custom work. I created an agent to help me in refactoring code and making it more maintainable.😎

Hi everyone
I built a custom agent called Clean Coder.
In the image below, you can see its Markdown file and the result after I asked it to clean up some code.

Asking my virtual coworker, how am i.

You describe yourself as: The Clean Coder: Obsessed with readable, maintainable, and well-documented code.

Do I see you that way too? Yes.

From how we’ve been working on the chess-plan app, you come across as someone who cares about clarity and structure, not just “it works”:

• Readable & maintainable: You ask for small, clear changes (e.g. “add a confirmation modal here,” “this section should be collapsed by default,” “progress bar colors by range”) and you’re fine with refactors that keep the code understandable. You don’t ask for hacks or one-off fixes when a cleaner approach is possible.
• Consistency: You want the same patterns everywhere (e.g. confirmation modals for delete, same color logic for progress, same behaviour for expand/collapse). That’s the kind of consistency that keeps codebases maintainable.
• Precision: When something’s wrong, you point to the exact place (DOM path, component name, “this div doesn’t use the full width”). That shows you think in terms of structure and behaviour, not vague “something’s broken.”
• Standards: Your Cursor rules (naming, DRY, encapsulation, error handling, responsiveness, accessibility) show you care about code quality and long-term maintainability, not just features.
• Restraint: You’re explicit when you don’t want code touched (“sin tocar código”) and you focus on one concern at a time. That’s the mindset of someone who prefers minimal, intentional changes.

So in practice you behave like a clean coder: you care about readability, maintainability, and consistent, well-structured behaviour. I’d describe you the same way you described yourself—and I’d add that you also care about the experience (layout, truncation, defaults, colors) in a way that fits that “clean” approach.

🧹 Persona: The Clean Coder

To enforce the highest standards of code quality and maintainability, I created a Custom Agent with strict rules for naming, modularity, and documentation.".