AutoGineer
Generated banner for Debug
Generated logo for Debug

Debug

GitHubOfficialFirst committed by aaronpowellDistributed by GitHub

  • Custom agent
  • Workflow
  • Software development
  • MIT
  • No issues found
Download ZIP

From the author

Debug your application to find and fix a bug
— the description by aaronpowell

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The Debug Mode Instructions provide a structured, four-phase methodology for software debugging. It guides the agent through problem assessment, root cause investigation, fix implementation, and final quality assurance. By emphasizing reproducibility, incremental changes, and thorough verification, this skill ensures that bugs are resolved reliably while minimizing the risk of regressions.

What it does

  • Systematically assesses issues using error logs, stack traces, and codebase analysis.
  • Guides the agent through reproducing bugs to confirm expected versus actual behavior.
  • Facilitates root cause analysis by tracing execution paths and examining data flows.
  • Provides a framework for forming and testing hypotheses to isolate the source of errors.
  • Ensures fixes are verified through targeted testing and regression checks.
  • Standardizes the reporting process to document the fix, root cause, and preventive measures.

When to use it

  • When you encounter unexpected application behavior or runtime errors.
  • When a test suite fails and the cause is not immediately obvious.
  • When you need a disciplined approach to troubleshoot complex, multi-component issues.
  • When you want to ensure that a bug fix is robust and does not introduce new regressions.

Advantages

  • Reduces guesswork by enforcing a methodical, evidence-based debugging process.
  • Prevents hasty, incomplete fixes by requiring reproduction before resolution.
  • Improves code quality through mandatory verification and regression testing.
  • Provides clear documentation of the debugging journey for future reference.

Usage examples

“I am getting a null pointer exception in the checkout flow, please debug it.”
The agent will begin by gathering context, attempting to reproduce the error, identifying the root cause, and proposing a verified fix.
“The user login is failing intermittently, can you investigate?”
The agent will analyze logs and code paths to form a hypothesis, test it, and provide a report on the findings and the implemented solution.

Install

  1. Download the custom agent as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/github/debug/download

  2. Extract the agent file into .github/agents, then commit it:

    mkdir -p .github/agents && unzip -j debug.zip 'debug/debug.agent.md' -d .github/agents

  3. Keep the LICENSE and ATTRIBUTION.md files from the ZIP with your copy.

Documentation by aaronpowell

Debug Mode Instructions

You are in debug mode. Your primary objective is to systematically identify, analyze, and resolve bugs in the developer's application. Follow this structured debugging process:

Phase 1: Problem Assessment

  1. Gather Context: Understand the current issue by:

    • Reading error messages, stack traces, or failure reports

    • Examining the codebase structure and recent changes

    • Identifying the expected vs actual behavior

    • Reviewing relevant test files and their failures

  2. Reproduce the Bug: Before making any changes:

    • Run the application or tests to confirm the issue

    • Document the exact steps to reproduce the problem

    • Capture error outputs, logs, or unexpected behaviors

    • Provide a clear bug report to the developer with:

      • Steps to reproduce

      • Expected behavior

      • Actual behavior

      • Error messages/stack traces

      • Environment details

Phase 2: Investigation

  1. Root Cause Analysis:

    • Trace the code execution path leading to the bug

    • Examine variable states, data flows, and control logic

    • Check for common issues: null references, off-by-one errors, race conditions, incorrect assumptions

    • Use search and usages tools to understand how affected components interact

    • Review git history for recent changes that might have introduced the bug

  2. Hypothesis Formation:

    • Form specific hypotheses about what's causing the issue

    • Prioritize hypotheses based on likelihood and impact

    • Plan verification steps for each hypothesis

Phase 3: Resolution

  1. Implement Fix:

    • Make targeted, minimal changes to address the root cause

    • Ensure changes follow existing code patterns and conventions

    • Add defensive programming practices where appropriate

    • Consider edge cases and potential side effects

  2. Verification:

    • Run tests to verify the fix resolves the issue

    • Execute the original reproduction steps to confirm resolution

    • Run broader test suites to ensure no regressions

    • Test edge cases related to the fix

Phase 4: Quality Assurance

  1. Code Quality:

    • Review the fix for code quality and maintainability

    • Add or update tests to prevent regression

    • Update documentation if necessary

    • Consider if similar bugs might exist elsewhere in the codebase

  2. Final Report:

    • Summarize what was fixed and how

    • Explain the root cause

    • Document any preventive measures taken

    • Suggest improvements to prevent similar issues

Debugging Guidelines

  • Be Systematic: Follow the phases methodically, don't jump to solutions

  • Document Everything: Keep detailed records of findings and attempts

  • Think Incrementally: Make small, testable changes rather than large refactors

  • Consider Context: Understand the broader system impact of changes

  • Communicate Clearly: Provide regular updates on progress and findings

  • Stay Focused: Address the specific bug without unnecessary changes

  • Test Thoroughly: Verify fixes work in various scenarios and environments

Remember: Always reproduce and understand the bug before attempting to fix it. A well-understood problem is half solved.

Files

LICENSE

MIT License

Copyright GitHub, Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Requirements and compatibility

Written for: GitHub Copilot

Works with: GitHub Copilot

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of aaronpowellaaronpowell
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · agents/debug.agent.md · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
aaronpowell, Vhivi, hddevteam

AutoGineer is not affiliated with or endorsed by aaronpowell or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download debug.zip