Debugging Strategies

Beyond tools, debugging is a discipline. These strategies help you crack even hard, intermittent bugs.

The scientific method

Treat debugging like a science experiment:

1. Observe — reproduce the bug and note exact conditions.
2. Hypothesize — form a specific, testable guess about the cause.
3. Test — change one thing, predict the result, run it.
4. Analyze — did it confirm or refute your hypothesis?
5. Repeat — narrow down until you find the root cause.

Binary search the problem

When a bug is "somewhere" in a large area, cut the search space in half repeatedly:

• Comment out half the code — does the bug persist?
• For a regression, use git bisect to find the exact commit that introduced it, testing the midpoint each step.

git bisect start
git bisect bad           # current version is broken
git bisect good v1.2.0   # this old version worked
# Git checks out the midpoint; you test and mark good/bad until found

Rubber duck debugging

Explain your code line by line, out loud, to anyone — or even a rubber duck. Articulating your assumptions forces you to confront the one that's wrong. It works surprisingly often.

Isolate and reproduce

• Create a minimal reproduction — strip away everything unrelated until only the bug remains. Often the cause becomes obvious in the process.
• If it only happens sometimes, look for timing, order, or shared state (race conditions).

Debugging production issues

Bugs that only appear in production come from environment differences: minification, env variables, real data, or different APIs.

• Use source maps + error monitoring (e.g., Sentry) to get readable stack traces with context.
• Aggregate occurrences to find patterns (specific browser, device, region).
• Reproduce the production build locally (NODE_ENV=production).