Systematic Debugging Protocol

A disciplined, evidence-based approach to debugging that prevents guessing and ensures root cause discovery.

The 4-Phase Protocol

Phase 1: REPRODUCE (Establish Ground Truth)

Goal: Create reliable reproduction steps before ANY investigation.

Actions:

1. Document exact steps to trigger the bug
2. Record environment specifics (OS, versions, config, memory, network)
3. Determine frequency: Always? Sometimes? Specific conditions?
4. Capture exact error messages, stack traces, screenshots
5. Test on different environments to isolate variables

Key Questions:

• When did it last work correctly?
• What changed since then? (code, deps, config, infrastructure)
• Is it environment-specific?
• Is it data-specific?
• Is it timing-specific?

Output: Clear reproduction steps that reliably trigger the issue.

Phase 2: ISOLATE (Narrow the Scope)

Goal: Reduce the search space from "entire codebase" to "specific component."

Techniques:

Binary Search:

1. Identify two points: working state and broken state
2. Test the midpoint
3. Recurse into the broken half
4. Continue until the change is identified

Git Bisect (for regressions):

git bisect start
git bisect bad HEAD
git bisect good <known-good-commit>
# Git will checkout commits for testing
# After each test:
git bisect good  # or git bisect bad
# Continue until culprit found

Code Elimination:

• Comment out sections to isolate the problem
• Create minimal reproduction case
• Strip away everything non-essential

Environment Isolation:

• Test in isolation (unit test the failing path)
• Compare working vs broken environments
• Use fresh installs to eliminate pollution

Output: "The bug is in [specific component/function/line range]"

Phase 3: DIAGNOSE (Understand Root Cause)

Goal: Know exactly WHY the bug occurs, not just WHERE.

Scientific Method:

1. Observe: What exactly is happening?
2. Hypothesize: Why might this be happening?
3. Predict: If hypothesis is correct, what else would be true?
4. Test: Verify predictions with evidence
5. Iterate: Refine hypothesis based on results

Logging Strategy:

// Add strategic logging at boundaries
console.log('[DEBUG] Function entry:', { input, state });
console.log('[DEBUG] After processing:', { result, sideEffects });
console.log('[DEBUG] Function exit:', { returnValue });

Common Root Causes:

Output: Clear explanation of the root cause with evidence.

Phase 4: FIX & VERIFY (Resolve and Prevent)

Goal: Fix the issue and prevent regression.

Fix Process:

1. Write a failing test that captures the bug
2. Implement minimal fix - change as little as possible
3. Verify test passes - confirms fix works
4. Check for similar patterns - same bug elsewhere?
5. Review fix for side effects - does it break anything?
6. Document the fix - why it happened, how to prevent

Verification Checklist:

• Test passes that specifically catches this bug
• Existing tests still pass
• Manual verification confirms fix
• Fix works in all affected environments
• No new warnings or errors introduced

Prevention:

• Add guards/validation at boundaries
• Improve error messages for easier future debugging
• Document gotchas for other developers
• Consider if architectural change prevents similar bugs

Debugging Anti-Patterns

DO NOT:

• Guess and hope (change things randomly)
• Assume you know the problem without evidence
• Trust comments/docs over actual code behavior
• Debug production with print statements you'll forget to remove
• Fix the symptom instead of the root cause
• Make multiple changes at once

DO:

• Verify assumptions with evidence
• Change one thing at a time
• Log actual values, not what you expect
• Trust the code over documentation
• Take breaks when stuck (fresh eyes help)

Quick Reference

1. REPRODUCE → Can I reliably trigger this?
2. ISOLATE   → Where exactly is it failing?
3. DIAGNOSE  → Why is it failing?
4. FIX       → How do I fix it permanently?

Output Template

## Bug Investigation: [Title]

### Reproduction
- Steps to reproduce
- Environment details
- Frequency

### Isolation
- Search method used
- Scope narrowed to

### Root Cause
- What's actually wrong
- Why it happens
- Evidence

### Fix
- Code changes made
- Test added

### Prevention
- How to prevent similar bugs
- Documentation updates