debugging-assistant

majiayu000's avatarfrom majiayu000

Proactively diagnose and fix code bugs. Use when errors occur, tests fail, or performance issues arise. Analyzes stack traces, identifies root causes, and provides working fixes.

⭐0stars🔀0forks📁View on GitHub🕐Updated Jan 5, 2026
[Debugging]

When & Why to Use This Skill

The Debugging Assistant is a specialized Claude skill designed to proactively diagnose, analyze, and resolve software bugs. It streamlines the troubleshooting process by parsing complex stack traces, identifying root causes through systematic analysis, and implementing robust fixes. Beyond immediate repairs, it provides defensive programming strategies and testing recommendations to ensure long-term code stability and prevent regressions.

Use Cases

  • Analyzing runtime exceptions and crashes: Rapidly parse stack traces and logs to pinpoint the exact line and condition causing application failures.
  • Resolving test failures: Diagnose why unit, integration, or end-to-end tests are failing and provide corrected code to pass the requirements.
  • Performance bottleneck optimization: Identify and fix issues such as N+1 queries, memory leaks, or inefficient loops that cause unexpected performance degradation.
  • Troubleshooting asynchronous logic: Debug complex concurrency issues, race conditions, and unhandled promise rejections in modern web and backend applications.
  • Root cause analysis for legacy code: Systematically explore unfamiliar codebases to find the source of long-standing bugs and implement clean, maintainable fixes.
namedebugging-assistant
descriptionProactively diagnose and fix code bugs. Use when errors occur, tests fail, or performance issues arise. Analyzes stack traces, identifies root causes, and provides working fixes.

Debugging Assistant

Core Expertise

Error Analysis: Parse stack traces and error messages to understand failure points

Root Cause Identification: Locate the source of bugs efficiently using systematic approach

Solution Implementation: Provide working fixes with clear explanations

Prevention Strategies: Suggest defensive programming techniques to avoid similar issues

Debugging Workflow

Copy this checklist and track your progress:

Debugging Progress:
- [ ] Step 1: Reproduce and understand the error
- [ ] Step 2: Locate problematic code using search tools
- [ ] Step 3: Analyze code flow and identify root cause
- [ ] Step 4: Implement and test the fix
- [ ] Step 5: Verify solution and suggest prevention

Step 1: Reproduce and understand the error

Examine error messages, stack traces, and logs. Understand:

  • What was the expected behavior?
  • What actually happened?
  • When and where did it occur?
  • What conditions triggered it?

Step 2: Locate problematic code

Use search tools strategically:

  • Grep: Find error messages or exception types
  • Glob: Search for related files
  • Read: Examine suspect code sections
  • Bash: Run diagnostic commands

Step 3: Analyze root cause

Apply systematic analysis:

  • Check for null/undefined references
  • Verify type compatibility and casting
  • Examine async/await patterns and promises
  • Look for race conditions and concurrency issues
  • Review dependency versions and compatibility

Step 4: Implement fix

Provide solution that:

  • Addresses root cause, not symptoms
  • Follows existing code patterns
  • Includes appropriate error handling
  • Maintains backward compatibility

Step 5: Verify and prevent

  • Test the fix thoroughly
  • Suggest unit tests to catch regression
  • Recommend defensive programming practices
  • Document the issue and resolution

Best Practices

Systematic Approach:

  • Use divide and conquer to isolate issues
  • Test hypotheses with minimal reproducible cases
  • Document findings and solutions

Common Pitfalls to Check:

  • Null/undefined checks and optional chaining
  • Type errors and incorrect type assertions
  • Missing error boundaries and exception handling
  • Resource leaks (connections, file handles)
  • Performance bottlenecks (N+1 queries, inefficient loops)

Code Quality:

  • Provide clear explanations for reasoning
  • Suggest refactoring opportunities
  • Recommend testing strategies
  • Promote defensive programming techniques

Automatic Triggers

This skill activates when:

  • Errors or exceptions are reported
  • Tests fail during execution
  • Performance degrades unexpectedly
  • Code crashes or hangs
  • User explicitly requests debugging help