A wrong assumption caught at turn 3 costs one sentence to fix. The same assumption caught at turn 40 costs a full re-brief. Nothing about the mistake changed — the context around it did.
Call it the correction tax. Every correction you issue to Claude Code mid-session has a price, paid in three currencies: model attention, tokens, and your own review time. The rate is not flat. It compounds with context depth.
Knowing when to interrupt Claude Code — and when to stop arguing with it — is the difference between a one-sentence fix and a lost afternoon. Here are the four moves, priced cheapest to dearest, plus a hard stop-loss rule.
Why late corrections cost more
Anthropic’s context-engineering post names the mechanism: “as the number of tokens in the context window increases, the model’s ability to accurately recall information from that context decreases.” Attention is a finite budget, and every token in the window competes for it.
Corrections make context rot worse in a specific way: the failed approach never leaves the room. After a long correction fight, the context holds three versions of the same function, the error output from each, and your instructions to abandon them all. Your latest instruction is one voice in a room you keep making louder.
There is a token bill too. Each retry is a full round-trip at the current context size. Three failed attempts at turn 40 are three turns each carrying tens of thousands of input tokens — the most expensive tokens you buy.
Watch for the tell that you are past steering: a fix that spawns a new problem. When “move the file” produces wrong namespace references and duplicate registrations, the model’s assumption is wrong, not its code. No number of corrections fixes context.
The structural fix is upstream: context budgeting, plus subagents as context firewalls to keep exploratory noise out of the main thread in the first place.
When to interrupt Claude Code mid-task
Four moves, ordered by price.
Steer — type and press Enter
Typing while Claude works does not interrupt anything. Claude Code queues your message instead of interrupting the turn, and Claude picks it up and adjusts without abandoning what it was doing. In-flight work survives.
use zod instead of yup — it’s already in package.json. keep everything else as planned
Cost: effectively zero.
Brake — press Esc
Esc stops Claude mid-action. The context is preserved, so you can redirect immediately; only the interrupted action is lost.
stop — auth logic lives in src/services/session.ts now. src/legacy/ is dead code scheduled for deletion. re-read the imports in src/app.ts to confirm, then continue
The decision rule between these first two moves: is the in-flight action worth keeping? Worth keeping — type and press Enter. Pure waste, or about to cause damage — hit Esc. Cost: one discarded action.
Amputate — /rewind to the bad turn
Every prompt creates a checkpoint, and checkpoints persist across sessions. /rewind (or Esc twice with an empty prompt) lists the prompts you sent in the session. Pick the one where things went wrong, then choose an action: restore code and conversation, restore only the conversation, restore only the code, or summarize the conversation from or up to that point.
Restoring code and conversation amputates the session at the exact turn the wrong assumption entered. Turn 12’s REST-versus-tRPC guess dies before it becomes load-bearing in the plan and the diff. Re-prompt with the assumption corrected upfront. The cost is only the turns after the bad one.
Checkpoints only track changes made by Claude’s file-editing tools. Files modified by bash commands (rm, mv, generated artifacts, migrations that ran) are not restored. Rewind is not a git replacement.
Reset — /clear plus a re-brief
When the pollution is spread across the whole session, amputation has nothing clean to cut back to. Run /clear and write a re-brief. This is the dearest move in effort — and past a threshold, the cheapest one available.
The two-correction stop-loss
Anthropic’s own docs are blunt about that threshold: “If you’ve corrected Claude more than twice on the same issue in one session, the context is cluttered with failed approaches. Run /clear and start fresh with a more specific prompt that incorporates what you learned.”
The same doc closes the argument: “A clean session with a better prompt almost always outperforms a long session with accumulated corrections.”
You will not want to stop. Addy Osmani calls this dynamic the 70% problem: the last stretch always feels one prompt away. His “two steps back” pattern names what actually happens — each fix breaks something else, and the tax you dodge converts into review debt on a diff nobody fully understands.
So make the rule mechanical. Two failed corrections on the same issue, and you stop. You will lose the argument with a degraded session; the only question is how many turns you pay before conceding.
The re-brief is the refund
/clear feels expensive because you delete everything. But the failed session’s real output was never the code — it was the constraints you discovered. Every correction you issued is a line in the next opening prompt.
> fix the login-after-timeout bug
> Fix the login-after-timeout bug. Context from a previous session, so you don't repeat dead ends: - the bug is in token refresh (src/auth/refresh.ts), NOT session creation — I verified session creation works - refreshToken() silently swallows the 401 from /oauth/token; the retry never fires - do NOT add retry logic in the middleware layer — we tried that, it double-refreshes - repro: npm test -- --grep 'expired session' (currently failing) Write a failing test first if the existing one doesn't cover the silent-swallow path, then fix, then run the full auth suite.
Two to five minutes of typing buys a context where constraints that took forty turns to surface sit at full attention, uncontested. A re-brief is a mini-spec, and spec-first prompting covers writing them well.
/compact is the discount option: the model summarizes the session and continues on the summary. It is cheap in effort but lossy in ways you do not control — a summary of a confused session is a confused summary. Steer it (/compact focus on the auth bug, drop the failed middleware attempts) when the session is merely noisy; when the session is wrong, reset. Surviving auto-compact covers those trade-offs in depth.
One more escape hatch. A correction you issue in every session is not a session problem. Advisory rules belong in CLAUDE.md, treated as a contract; rules that must never be skipped belong in hooks, which are deterministic where CLAUDE.md is advisory.
Keep a scratch note of corrections as you issue them. When you hit the two-correction stop-loss, the re-brief writes itself: paste the note under “context from the previous session” and go.
Prepay the tax instead
The cheapest correction is the one you never issue. Plan mode surfaces wrong assumptions while they cost one read instead of a diff review — that is the case for plans worth approving.
A runnable check goes further: it makes the test suite your interrupt handler. Corrections issued by a failing test are free, run at machine speed, and never queue behind your attention. Verification loops are how you set that up.
The counterweight: planning has overhead too, and the official docs say to skip it when the change is small and obvious. Prepaying on trivial tasks is its own tax.
When riding it out is right
Not every long session deserves a reset. A deep debugging session whose history holds real signal — hypotheses tested, dead ends mapped — can be worth more than a clean context. The stop-loss targets repeated corrections on one issue, not long sessions in general.
Scope matters too: everything here applies to interactive sessions. You cannot interrupt Claude Code in a headless run — there is no Esc to press. Its correction story is verification, not interruption.
Rules of thumb
- In-flight action worth keeping: type the correction and press Enter.
- Action is waste or damage: press Esc, then redirect.
- Wrong assumption with an identifiable entry turn:
/rewind, restore code and conversation, re-prompt. - Pollution everywhere, or two corrections on one issue failed:
/clear, re-brief from your notes. - Same correction across sessions: move it to CLAUDE.md or a hook.
The tax itself is unavoidable. Paying it early — or prepaying it as spec and verification — is the whole game.
Across a team, the tax shows up as uneven results: one engineer resets after two failed corrections, another argues with a degraded session for an hour. When we roll Claude Code out with a team, we make these moves shared vocabulary and turn repeated corrections into shared CLAUDE.md rules and hooks. That coaching is part of our Enable work.
Next steps
- The escalation ladder for agentic tasks — choose the right autonomy level before the session starts.
- Reviewing AI diffs without rubber-stamping — the review side of the tax.
- Instrument your Claude Code usage — measure what your corrections actually cost.