Skip to main content
reopt Handbook
reopt Handbook
Developer Unlearning

Why Change

When Expertise Becomes WeightThe Illusion That I Must Write Everything

Design and Implementation Shift

From Up-Front Design to Iterative DesignPrompts Are Design LanguageCode Review in the AI Era

Practice Reset

Testing Strategy ShiftDebugging Habit ResetContext Management: The New Core SkillRedefining Technical Debt

Team and Career

Team Workflow ChangeWhat Not to UnlearnAgentic Transition Strategy

Appendix

Verification ReportUpdate Log
Handbook›Developer Unlearning›Debugging Habit Reset
한국어English

Debugging Habit Reset

Move from trace-by-instinct to hypothesis-driven debugging with AI.

Key takeaways

  • AI-assisted debugging replaces "where do I put the next log?" with "why would this symptom occur?", turning debugging into a hypothesis-ranking loop.
  • A debugging context template (symptom, reproduction, already checked, suspected area) turns a vague "fix this error" into a request that gets ranked causes plus verification steps.
  • AI is good at ranking likely causes, spotting server/client assumption mismatches, and producing a minimal fix once the cause is confirmed.
  • Humans still own reproducing the bug, confirming facts over plausible explanations, choosing the safest fix, and adding regression tests.
  • The review checklist closes the loop: capture the symptom, ensure reproduction, rank hypotheses, add a regression test, and document root cause not just the patch.

Classic debugging often starts with "where should I put the next log?" or "where should I set a breakpoint?" AI-assisted debugging starts with a different question: "Why would this symptom occur?"

The Old Loop

ToolStrengthLimit
console.logSimple and universalYou must guess where to look
DebuggerPrecise state and call stackYou still choose the path by instinct
Manual readingBuilds deep understandingSlow when the search space is large

These tools remain useful. The problem is direction. They tell you what happened at a point; they do not rank where to look first.

Hypothesis-Driven Debugging

Debugging Context Template

### Symptom
- Exact error message
- Expected vs actual behavior

### Reproduction
- Environment
- Steps
- Frequency

### Already checked
- Facts confirmed
- Hypotheses ruled out

### Suspected area
- Recent changes
- Related modules
- What feels unusual

Bad request:

Fix this error:
TypeError: Cannot read property 'map' of undefined

Better request:

Symptom: User list page throws "Cannot read property 'map' of undefined" only on first load.
Reproduction: after login, direct navigation to /users. Sidebar navigation does not reproduce it.
Checked: users state initializes as [], API returns 200 with array data.
Suspected area: SSR/CSR hydration timing or useEffect ordering.
Relevant files: app/users/page.tsx, hooks/useUsers.ts.
Return likely causes ranked by probability and one verification step for each.

What AI Is Good At

  • Ranking likely causes from error type and framework patterns.
  • Noticing mismatches between server and client assumptions.
  • Suggesting quick verification steps.
  • Explaining why a symptom appears only under certain conditions.
  • Producing a minimal fix after the cause is confirmed.

What Humans Still Own

  • Reproducing the bug.
  • Confirming facts instead of accepting plausible explanations.
  • Choosing the safest fix for the system.
  • Adding regression tests.
  • Writing the postmortem or runbook when the bug matters.

Debugging Review Checklist

CheckQuestion
Symptom capturedIs the exact error and expected behavior recorded?
Reproduction knownCan another person or agent reproduce it?
Hypotheses rankedAre we checking the most likely cause first?
Regression test addedWill this failure be caught next time?
Root cause documentedDid we record why the bug happened, not only the patch?

Next

Read Context Management to improve the quality of the information you give AI.

Related docs

Monitoring and Incident

Enterprise Project Architecture · Operate logs, metrics, traces, alerts, runbooks, and post-incident learning.

Testing Strategy Shift

From tests after implementation to tests that drive AI-assisted implementation.

Context Management: The New Core Skill

Decide what AI needs to know, what to omit, and when to reset context.

On this page

The Old LoopHypothesis-Driven DebuggingDebugging Context TemplateWhat AI Is Good AtWhat Humans Still OwnDebugging Review ChecklistNext