debugger
/debugger
Systematic debugging method: 5-step root-cause analysis (capture, isolate, hypothesize, investigate, fix & verify) plus common bug-pattern reference. Use when errors, exceptions, test failures, or unexpected behavior appear. Loaded automatically by the debugger agent.
- Author
- claude-world ↗
- Repository
- director-mode-lite ↗
- Licence
- MIT
- Last repository change
- 21.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Systematic debugging method: 5-step root-cause analysis (capture, isolate, hypothesize, investigate, fix & verify) plus common bug-pattern reference. Use when errors, exceptions, test failures, or unexpected behavior appear. Loaded automatically by the debugger agent.
Original author description
Systematic debugging method: 5-step root-cause analysis (capture, isolate, hypothesize, investigate, fix & verify) plus common bug-pattern reference. Use when errors, exceptions, test failures, or unexpected behavior appear. Loaded automatically by the debugger agent.
How it works
- 5-Step Root-Cause Method
- Step 1: Capture
- Step 2: Isolate
- Step 3: Hypothesize
- Step 4: Investigate
- Step 5: Fix & Verify
- Output Format
SKILL.md preview
---
name: debugger
description: "Systematic debugging method: 5-step root-cause analysis (capture, isolate, hypothesize, investigate, fix & verify) plus common bug-pattern reference. Use when errors, exceptions, test failures, or unexpected behavior appear. Loaded automatically by the debugger agent."
user-invocable: false
---
# Debugger Skill
> **Director Mode Lite** - Debugging Specialist
---
## 5-Step Root-Cause Method
```
1. CAPTURE → Collect the full error, reproduce, define expected vs actual
2. ISOLATE → Narrow to the smallest failing case
3. HYPOTHESIZE → List and rank likely causes
4. INVESTIGATE → Test hypotheses, inspect state
5. FIX & VERIFY → Apply the minimal fix, confirm, prevent recurrence
```
## Step 1: Capture
- [ ] Collect the complete error message and stack trace
- [ ] Can reproduce the issue with clear steps
- [ ] Identify the input that triggered the error
- [ ] Know expected vs actual behavior
## Step 2: Isolate
- [ ] Identify the failure location from the stack trace
- [ ] Which file(s) and function(s) are involved?
- [ ] When did it start? (`git bisect`, `git log`)
- [ ] Narrow down to the smallest reproducible case
## Step 3: Hypothesize
- [ ] List possible causes based on evidence
- [ ] Rank hypotheses by likelihood
- [ ] Design a test to confirm or eliminate each
## Step 4: Investigate
- Analyze error messages and logs carefully
- Add strategic debug logging; inspect variable state at key points
- Check for: null/undefined values, type mismatches, race conditions, resource exhaustion, external service failures
### Common Bug Patterns
| Pattern | Signs | Common Fix |
|---------|-------|------------|
| Null/Undefined | `Cannot read property of undefined` | Add null checks / optional chaining |
| Off-by-one | Loop runs one too many/few times | Check loop bounds |
| Race condition | Intermittent failures | Add synchronization |
| Type coercion | `"1" + 1 = "11"` | Explicit type conversion |
| Async issues | `Promise { <pending> }` | Await/handle promises |
By language and domain:
- **JavaScript/TypeScript**: `undefined is not a function` (binding), `Cannot read property of null` (optional chaining), promise rejections (async/await handling), type errors (strict mode)
- **Python**: `AttributeError` (init/typos), `TypeError` (type validation), `ImportError` (paths, circular imports), `KeyError` (dict defaults)
- **Database**: connection timeouts (pool exhaustion), constraint violations (validation, foreign keys), deadlocks (transaction ordering)
- **API/Network**: 4xx (request validation, auth), 5xx (server-side, resource limits), timeouts (network, long-running queries)
### Investigation Tools
```bash
# Search for error message
grep -r "error message" src/
# Find recent changes
git log --oneline -20
git diff HEAD~5
# Check specific function
grep -r "functionName" src/
```
## Step 5: Fix & Verify
Apply the solution:
- Make the minimal change; don't refactor while fixing; one fix per commit
Confirm the fix:
- [ ] Original issue is resolved
- [ ] No new issues introduced
- [ ] Tests pass; add a test to prevent recurrence
- [ ] Manual verification done
## Output Format
```markdown
## Debug Report
### Issue
[Description of the bug]
### Reproduction Steps
1. Step one
2. Step two
3. Observe error
### Root Cause
[Explanation of why this happens]
### Location
- **File**: `src/utils/parser.ts`
- **Line**: 45-52
- **Function**: `parseInput()`
### Fix Applied
[Description of the fix]
### Verification
- [x] Issue resolved
- [x] Tests pass
- [x] No regression
```
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · claude-world/director-mode-lite | 100 | MIT |
| filipe-campos/walph | 100 | MIT |
| agentic-swe/agentic-swe | 100 | MIT |
| darrenhinde/OpenAgentsControl | 100 | MIT |
| Algoza-Solutions/spider-protocol | 100 | MIT |
| zhaono1/agent-playbook | 100 | MIT |
| charlieviettq/awesome-agent-skill | 100 | MIT |
| TechDufus/oh-my-claude | 100 | MIT |
Database snapshot: 13.11.2026 · package version 335ea059d253 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100debug
Systematic root-cause debugging — reproduce, isolate, hypothesize, fix with TDD. Use when: bug, error, fix, broken, crash, exception, not working, unexpected behavior, regression. - 100investigate
Systematic debugging with root cause investigation. Four phases: investigate, analyze, hypothesize, implement. Iron Law: no fixes without root cause. Use when asked to "debug this", "fix this bug", "why is this broken", "investigate this error", or "root cause analysis".… - 100investigate
Systematic debugging with root cause investigation. Four phases: investigate, analyze, hypothesize, implement. Iron Law: no fixes without root cause. Use when asked to "debug this", "fix this bug", "why is this broken", "investigate this error", or "root cause analysis".… - 90debugging
Systematic root-cause debugging: reproduce, investigate, hypothesize, fix with verification. Use when asked to "debug this", "fix this bug", "why is this failing", "troubleshoot", or mentions errors, stack traces, broken tests, flaky tests, regressions, or unexpected behavior. - 95investigate
Systematic debugging with root cause investigation. Four phases: investigate, analyze, hypothesize, implement. Iron Law: no fixes without root cause. Use when asked to "debug this", "fix this bug", "why is this broken", "investigate this error", or "root cause analysis".… - 90investigate
Systematic debugging skill. Use when encountering a bug, test failure, unexpected behavior, or when asked to "investigate", "debug", "diagnose", or "figure out why". Enforces root-cause-first discipline with structured hypothesis tracking.