Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use when investigating bugs, performance issues
Install
The skill file stays in the publisher's repository.
Paste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add wshobson/agents --skill debugging-strategies -a cursor -y
Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use when investigating bugs, performance issues, or unexpected behavior.
Questions
How do I install debugging-strategies?
Download plugins/developer-essentials/skills/debugging-strategies/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
Where does debugging-strategies live?
The publisher keeps it at https://github.com/wshobson/agents.
Which agents can use debugging-strategies?
Claude, Cursor, and Codex can read a SKILL.md you add from the publisher's repository.
Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use when investigating bugs, performance issues, or unexpected behavior.
name: debugging-strategies
description: Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use when investigating bugs, performance issues, or unexpected behavior.
Debugging Strategies
Transform debugging from frustrating guesswork into systematic problem-solving with proven strategies, powerful tools, and methodical approaches.
When to Use This Skill
Tracking down elusive bugs
Investigating performance issues
Understanding unfamiliar codebases
Debugging production issues
Analyzing crash dumps and stack traces
Profiling application performance
Investigating memory leaks
Debugging distributed systems
Core Principles
1. The Scientific Method
1. Observe: What's the actual behavior?
2. Hypothesize: What could be causing it?
3. Experiment: Test your hypothesis
4. Analyze: Did it prove/disprove your theory?
5. Repeat: Until you find the root cause
2. Debugging Mindset
Don't Assume:
"It can't be X" - Yes it can
"I didn't change Y" - Check anyway
"It works on my machine" - Find out why
Do:
Reproduce consistently
Isolate the problem
Keep detailed notes
Question everything
Take breaks when stuck
3. Rubber Duck Debugging
Explain your code and problem out loud (to a rubber duck, colleague, or yourself). Often reveals the issue.
Systematic Debugging Process
Phase 1: Reproduce
## Reproduction Checklist
1. **Can you reproduce it?**
- Always? Sometimes? Randomly?
- Specific conditions needed?
- Can others reproduce it?
2. **Create minimal reproduction**
- Simplify to smallest example
- Remove unrelated code
- Isolate the problem
3. **Document steps**
- Write down exact steps
- Note environment details
- Capture error messages
Phase 2: Gather Information
## Information Collection
1. **Error Messages**
- Full stack trace
- Error codes
- Console/log output
2. **Environment**
- OS version
- Language/runtime version
- Dependencies versions
- Environment variables
3. **Recent Changes**
- Git history
- Deployment timeline
- Configuration changes
4. **Scope**
- Affects all users or specific ones?
- All browsers or specific ones?
- Production only or also dev?
Phase 3: Form Hypothesis
## Hypothesis Formation
Based on gathered info, ask:
1. **What changed?**
- Recent code changes
- Dependency updates
- Infrastructure changes
2. **What's different?**
- Working vs broken environment
- Working vs broken user
- Before vs after
3. **Where could this fail?**
- Input validation
- Business logic
- Data layer
- External services
Phase 4: Test & Verify
## Testing Strategies
1. **Binary Search**
- Comment out half the code
- Narrow down problematic section
- Repeat until found
2. **Add Logging**
- Strategic console.log/print
- Track variable values
- Trace execution flow
3. **Isolate Components**
- Test each piece separately
- Mock dependencies
- Remove complexity
4. **Compare Working vs Broken**
- Diff configurations
- Diff environments
- Diff data
Before selecting debugging tools or performing bisect, differential, trace, or memory analysis, read references/tools-and-techniques.md.
Debugging Patterns by Issue Type
Pattern 1: Intermittent Bugs
## Strategies for Flaky Bugs
1. **Add extensive logging**
- Log timing information
- Log all state transitions
- Log external interactions
2. **Look for race conditions**
- Concurrent access to shared state
- Async operations completing out of order
- Missing synchronization
3. **Check timing dependencies**
- setTimeout/setInterval
- Promise resolution order
- Animation frame timing
4. **Stress test**
- Run many times
- Vary timing
- Simulate load
## Production Debugging
1. **Gather evidence**
- Error tracking (Sentry, Bugsnag)
- Application logs
- User reports
- Metrics/monitoring
2. **Reproduce locally**
- Use production data (anonymized)
- Match environment
- Follow exact steps
3. **Safe investigation**
- Don't change production
- Use feature flags
- Add monitoring/logging
- Test fixes in staging
Best Practices
Reproduce First: Can't fix what you can't reproduce
Isolate the Problem: Remove complexity until minimal case
Read Error Messages: They're usually helpful
Check Recent Changes: Most bugs are recent
Use Version Control: Git bisect, blame, history
Take Breaks: Fresh eyes see better
Document Findings: Help future you
Fix Root Cause: Not just symptoms
Common Debugging Mistakes
Making Multiple Changes: Change one thing at a time
Not Reading Error Messages: Read the full stack trace
Assuming It's Complex: Often it's simple
Debug Logging in Prod: Remove before shipping
Not Using Debugger: console.log isn't always best
Giving Up Too Soon: Persistence pays off
Not Testing the Fix: Verify it actually works
Quick Debugging Checklist
## When Stuck, Check:
- [ ] Spelling errors (typos in variable names)
- [ ] Case sensitivity (fileName vs filename)
- [ ] Null/undefined values
- [ ] Array index off-by-one
- [ ] Async timing (race conditions)
- [ ] Scope issues (closure, hoisting)
- [ ] Type mismatches
- [ ] Missing dependencies
- [ ] Environment variables
- [ ] File paths (absolute vs relative)
- [ ] Cache issues (clear cache)
- [ ] Stale data (refresh database)
How do I install debugging-strategies?
Download plugins/developer-essentials/skills/debugging-strategies/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
Where does debugging-strategies live?
The publisher keeps it at https://github.com/wshobson/agents.
Which agents can use debugging-strategies?
Claude, Cursor, and Codex can read a SKILL.md you add from the publisher's repository.