Debugging is simulation, not typing
When you debug, you build a private model of cause and effect: which branch ran, which state was wrong, which assumption failed. The model lives in working memory. It is large, fragile, and almost never written down completely.
Typing a fix is the last step. Most of the clock is updating the model after each experiment.
An interruption does not pause the simulation. It deletes it.
The real cost curve
People quote "twenty-three minutes to refocus" from old studies. For debugging, the honest cost is often worse because recovery is not generic refocus. You must rebuild:
- Which test failed and with what seed
- Which breakpoint is still set
- Which log filter was applied
- The last hypothesis you were about to disprove
- Dirty local state you forgot to note
A ninety-second question can produce a twenty-minute rebuild even if you answer in ten words.
Know the fragile zone
You are in the expensive zone when:
- You are stepping through code with a hypothesis
- Flaky test behavior finally reproduced
- Production issue with incomplete logs
- Race or timing bug under observation
- You have more than six tabs or buffers tied to one thread
In that zone, treat chat like a fire alarm, not a doorbell.
The sixty-second park still applies
You will be interrupted. Before you stand up, write:
- Next experiment in one line
- Failing assertion or request id
- Branch and dirty files
- Command to rerun the test
The park protocol from working from home when interrupted is not household-only. It is debugger insurance.
Team norms that help
Tier-one channel for production down only.
Async by default for questions that can wait one overlap window.
Context in the first message: environment, repro, what you tried.
No "you got a sec?" without the question attached.
Leaders who ping for status during red-ticket work teach everyone to hide state. Status belongs in written updates (async status).
Pairing is not interruption if roles are clear
Driver/navigator pairing can preserve the model because both hold context. Random shoulder taps do not.
If you pull someone into debug, give them the ticket thread first. Let them read before you talk.
When to stop fighting and document
If interrupts won, switch modes. Spend fifteen minutes writing repro, logs, and next experiments in the ticket. You buy back parallelism: others can read while you handle the ping.
That is cheaper than pretending you still hold the full model.
Related costs
Context switching covers non-debug tasks. Deep work for developers covers block sizing.
Protecting debug time is not antisocial. It is how incidents end faster. The fix ships when the model survives long enough to change the code with evidence.
On-call and fragile zones
During incidents, depth is mandatory and interrupts are constant. Reduce damage by assigning roles: one person holds the model, one handles comms, one gathers logs.
Without roles, everyone pings the debugger with partial facts and the model resets every two minutes.
Post a single incident thread. Questions go there, not side DMs.
Rubber duck before you ping someone else
Write the hypothesis and disproof you tried. Often the act of writing surfaces the bug without exporting your reset cost to a teammate.
When you do ping, send repro steps, not urgency adjectives.
Recovery when you already lost the model
Stop debugging for ten minutes. Write timeline, facts, and next experiments. Treat yourself as a new investigator.
Starting fresh with notes beats thrashing for an hour pretending you still remember branch state.
Metrics that lie
Lines of code and commit count rise when people switch often because each switch produces tiny commits and comment fixes. Watch reviewable outcomes instead.
If your team measures activity, debugging will look unproductive right when it is most valuable. Push back with ticket evidence, not hours at keyboard.
Ask for quiet windows during sev-1 only for the person holding the trace, the same way you would not pull a surgeon mid-incision for a status photo.