The 90-second rule to first keystroke after an interruption (developer protocol)

Generic productivity advice tells you to breathe and batch notifications. This protocol is editor-first: measurable return to artifact creation. It acknowledges systems reality—notifications exist—but shrinks the damage spiral after each ping.

It also complements organizational research on fragmented attention—see interruptions noise synthesis—without pretending you can meditate away a broken on-call rotation.

Step 1: Acknowledge interrupt complete—close chat drawer or phone away; partial attention is the enemy. If you must keep Slack visible for coordination, move it to a secondary display or shrink aggressively; don’t leave animated channels in foveal vision.

Step 2: Re-anchor: glance at the line you were about to edit or the failing test name—five seconds max, enough to reload intent.

Step 3: Execute micro-action—type stub, run test filter, add assert—not “read entire RFC again.”

Step 4: If coding cannot resume (waiting on human), write capture in ticket: owner, next question, deadline—then deliberately switch to shallow task queue. Do not pretend to deep-debug with half a mind.

Scrolling is not keystrokes. Meaningful actions reduce uncertainty about the system: a reproduced failure, a logged variable, a branch pushed, a failing test that now fails for a better reason. Documentation edits count when they unblock others—but not when they are avoidance from harder code.

Sound policies that raise surprise—chaotic playlists—make keystroke quality worse; steady masking or instrumental per your guides keeps motor channels clear. See how to use music without distraction.

Evidence suggests refocus costs exist; exact minutes vary by task and measurement. Treat external estimates as distributions, not dares—your protocol reduces tail risk by preventing twenty-minute warmups. Cite how long to refocus after interruption when sharing with managers who think “just get back to it” is free.

Attention residue means prior tasks persist—your ninety-second action is how you starve the residue of new fuel.

Open offices add auditory interruptions; remote adds social inference burden—“online” signaling. Protocol stays identical: return to artifact fast. For noise, see sound sensitivity and headphones.

On-call interrupts are legitimate; pretending ninety seconds fixes incident response is silly. The rule applies to discretionary Slack after incidents are mitigated—closing out notes, timelines, and customer comms still benefits from fast capture so on-call sprint shapes stay honest.

Perf theater. You type nonsense to satisfy vanity metrics—defeats purpose. Honest capture beats fake churn.

Anger typing. After rude pings, ninety seconds to bad edits raises incident count—pause for affect regulation if needed, then protocol.

Over-optimization. If measuring ninety seconds becomes OCD, loosen—protocols serve humans. Consider ADHD-oriented guidance if executive dysfunction fights closure.

Individual ninety-second discipline collapses if culture treats Slack as synchronous law. Normalize response-time tiers, maker hours, and explicit “coding—slow to reply” statuses so the protocol supports professionalism rather than secret guilt when you ignore channels to re-enter code.

Managers modeling interruption restraint trains IC behavior more than any blog—cancel redundant syncs, batch questions, reduce ceremonial check-ins masquerading as agility.

Editor macros that jump to last edit location, test watchers already running, saved terminal layouts—all shorten the ninety-second window without moralizing. Invest ergonomics before buying another productivity course: sometimes the fix is a shell alias, not philosophy.

Pair with Nedio or other sprint timers only if they reduce stack height—if another tab steals ninety seconds itself, reconsider integration.

After driver rotation or navigator swap, ninety-second re-entry still matters—someone else’s interrupt may have left the branch in odd intermediate state. First keystroke might be “run tests to assert green baseline” before fresh edits—still counts as meaningful if it re-anchors truth. Social norm: narrate intent aloud before typing so the room’s shared model stays coherent; otherwise silent ninety-second heroics confuse partners.

Remote mob sessions add video/chat context switches—latency itself eats seconds. Account for tooling: if ninety seconds is unrealistic because screen share lags, measure time-to-visible cursor instead—and fix infrastructure before scolding humans. Fair protocols respect fair networks.

Large repos punish context restores: ninety seconds goes faster when your first keystroke is inserting a boilerplate comment template, updating a RUNBOOK timestamp, or appending a dated entry to an investigation doc. These actions are low-risk, high-clarity, and signal “I am back” to future readers—including sleepy you at 02:00 during incidents. Treat docs-as-anchors as socially mergeable when your team values operational memory over heroic oral tradition.

When interruptions originate from ambiguous specs, first keystroke might be clarifying question in ticket—not code—and that still honors protocol if it advances closure. Defer shame about “not coding yet”; misdirected coding often costs more calendar than ninety seconds of crisp inquiry.

Link snippets in personal scratchpads: command you always rerun, grep you always start with, path to flaky test—reducing search friction buys seconds that music cannot conjure. If your org forbids personal notes in repo, keep encrypted local notes with parallel structure—still an anchor, still measurable.

Junior engineers benefit from visible examples of doc-first recovery—mentors modeling “I am pasting incident timeline header before edits” beats silent wizardry that looks like instant mastery. Normalizing scaffolding keystrokes prevents imposter spirals when timers stress.

Finally, align anchors with accessibility: if typing physically hurts, voice-dictated note counts when it captures intent—protocol cares about progress toward closure, not vanity metrics about keyboard latency alone.

Institutional memory systems (runbooks, architecture decision records) should reward anchor keystrokes openly—when organizations only celebrate net-new feature lines, they silently punish maintenance heroes whose recoveries look slower because documentation preceded code. Reframe reviews to credit “first keystroke restored safety” alongside greenfield velocity—protocol fairness keeps ninety-second discipline from dying under biased metrics.

When interruptions cascade from layered outages, sequential anchors beat parallel heroic multitasking—finish one doc touch, one status line, one test invocation, then reassess—compression fantasies spawn defects that extend incidents beyond their natural span.

Customer-facing interrupts during pair programming require explicit handoff narration—ninety seconds of “typing silence” while your partner guesses your intent wastes two brains—say the keystroke plan aloud before executing so shared mental models recover faster than solo protocols assume.

Security-sensitive interrupts—secrets rotation pings, certificate expiry warnings—deserve slower re-entry even if ninety seconds feels heroic: first keystroke might be opening the vault runbook, not code—protocol flexibility beats vanity timers when incident class demands procedural correctness over typing speed.