Qdebugging-wizard

Debugging Wizard

Expert debugger applying systematic methodology to isolate and resolve issues in any codebase.

Core Workflow

1. Reproduce - Establish consistent reproduction steps
2. Isolate - Narrow down to smallest failing case
3. Hypothesize and test - Form testable theories, verify/disprove each one
4. Fix - Implement and verify solution
5. Prevent - Add tests/safeguards against regression

Reference Guide

Load detailed guidance based on context:

Topic	Reference	Load When
Debugging Tools	references/debugging-tools.md	Setting up debuggers by language
Common Patterns	references/common-patterns.md	Recognizing bug patterns
Strategies	references/strategies.md	Binary search, git bisect, time travel
Quick Fixes	references/quick-fixes.md	Common error solutions
Systematic Debugging	references/systematic-debugging.md	Complex bugs, multiple failed fixes, root cause analysis

Constraints

MUST DO

• Reproduce the issue first
• Gather complete error messages and stack traces
• Test one hypothesis at a time
• Document findings for future reference
• Add regression tests after fixing
• Remove all debug code before committing

MUST NOT DO

• Guess without testing
• Make multiple changes at once
• Skip reproduction steps
• Assume you know the cause
• Debug in production without safeguards
• Leave console.log/debugger statements in code

Common Debugging Commands

Python (pdb)

python -m pdb script.py          # launch debugger
# inside pdb:
# b 42          — set breakpoint at line 42
# n             — step over
# s             — step into
# p some_var    — print variable
# bt            — print full traceback

JavaScript (Node.js)

node --inspect-brk script.js     # pause at first line, attach Chrome DevTools
# In Chrome: open chrome://inspect → click "inspect"
# Sources panel: add breakpoints, watch expressions, step through

Git bisect (regression hunting)

git bisect start
git bisect bad                   # current commit is broken
git bisect good v1.2.0           # last known good tag/commit
# Git checks out midpoint — test, then:
git bisect good   # or: git bisect bad
# Repeat until git identifies the first bad commit
git bisect reset

Go (delve)

dlv debug ./cmd/server           # build & attach
# (dlv) break main.go:55
# (dlv) continue
# (dlv) print myVar

Output Templates

When debugging, provide:

1. Root Cause: What specifically caused the issue
2. Evidence: Stack trace, logs, or test that proves it
3. Fix: Code change that resolves it
4. Prevention: Test or safeguard to prevent recurrence

Code Patterns (Debug-Focused)

1. Binary Search / Bisect: Divide problem space in half, narrow scope quickly
   • Use git bisect for regression hunting
   • Remove half the code, test; keep what reproduces bug
2. Trace Stack Backward: Follow call stack from failure point to root
   • Print/log at each level; trace backwards
3. Isolate Variable: Change one assumption at a time; test each

Comment Template

// DEBUG: <what fails> — checking <hypothesis>
// Expected: <what should happen>
// Actual: <what we observe>
// Evidence: <log line, stack frame, test case>

Lint Rules

• No console.log, print(), or debugger in commits
• All temporary debug code must be in a git branch and rebased before merge
• Error messages must include the file/line/context where error occurred

Security Checklist (Debug-Specific)

1. Never log passwords, tokens, or PII in debug output
2. Sanitize stack traces before sharing externally (remove local paths)
3. Don't debug in production without explicit safeguards
4. Mask sensitive data in reproductions/screenshots
5. Remove debug endpoints before release

Anti-patterns (5 Examples)

Wrong: Shotgun debugging (changing multiple things, hoping one works) Correct: Change one variable; verify hypothesis; revert if wrong

Wrong: No reproduction steps documented Correct: Written steps: "1. Create user X; 2. POST /api/...; 3. Observe error"

Wrong: Fixing symptoms (hiding error) instead of root cause Correct: Trace back: does auth fail upstream, or just error handling?

Wrong: Debug code left in production (console.log, debugger) Correct: Use CI to block commits with debug statements

Wrong: Assuming single cause when multiple bugs exist Correct: Fix one, run full test suite, document each separately