What actually broke in Claude Code: a walk through Anthropic's context management bug

If you were using Claude Code in early April and felt like it had quietly become worse, forgetting things you'd just told it, picking the wrong tool for jobs it had handled fine the day before, sometimes losing the thread mid-task, you weren't imagining it. Anthropic published an engineering postmortem this week explaining what happened, and the explanation is genuinely interesting. Two unrelated changes collided. One of them broke something subtle about how Claude remembers what it's been thinking. The other made the symptoms worse in a way that masked the real cause.

I want to walk through what actually went wrong, because the bug sits at the intersection of two ideas, extended thinking and context management, that most people using these tools haven't had a reason to look at closely. Once you see how they fit together, the failure mode is almost obvious. And it tells you something useful about where the seams are in modern coding agents.

The two ideas you need first

Context is the running record of a conversation that gets handed back to the model every turn. Models don't have memory in the way you or I do. Each time you send Claude a message, the system bundles up the relevant history, your previous messages, Claude's previous replies, the tools it called, what those tools returned, and sends the whole bundle as input. The model reads the entire bundle, then produces its next response. Then that response gets added to the bundle for next time.

This is why context windows matter. It's also why "memory" in an LLM is really just the question of what you choose to put back into the bundle on each turn.

Extended thinking is a feature where the model produces a block of internal reasoning before it produces its actual answer. You can think of it as scratch work. The model writes out "okay, the user wants me to refactor this function, but first I should check what calls it, so I should use the grep tool, and then…", and that reasoning, in models that support it, is preserved and shown to the model on subsequent turns. Not just the final answer, but the thinking that produced the answer.

The reason this matters for a coding agent is that good tool use depends on continuity of reasoning. If Claude decided three turns ago that this codebase uses a particular pattern, and it wrote that observation into its thinking block, then on turn four it can pick up where it left off. Without the thinking history, turn four sees only the outputs of previous turns, the tool calls and their results, but not the reasoning that connected them. It's the difference between reading a detective's notes and reading only the list of clues they collected.

What broke

Here's where the bug lived. Claude Code's context management has logic for trimming history when sessions get long or go idle. This is necessary, context windows are finite, and you don't want a session that's been running all afternoon to start hitting limits or burning tokens on stale information.

The trimming logic had a threshold for idle sessions: after a certain period of inactivity, when the user came back and sent a new message, the system would compact the context to keep things tight. The intent was reasonable. The bug was that the compaction step was dropping the extended-thinking blocks from prior turns every turn after the threshold was crossed, not just once at the moment of compaction.

So what the model saw, on each new turn after an idle session resumed, was: your messages, its prior outputs, the tool calls and results, but not the reasoning that connected any of them. The detective's clue list, no notes.

The symptoms followed directly. Claude would seem to forget conclusions it had reached earlier in the same session. It would re-investigate things it had already investigated. It would pick tools that didn't quite fit the task, because the reasoning that would have led it to the right tool was no longer in front of it. From the user's side it looked like the model had gotten dumber. From the model's side, it was being asked to continue a train of thought it could no longer see.

This is the part I find genuinely instructive. The model itself wasn't broken. The weights hadn't changed. What changed was what the model could see of its own prior work, and that turns out to matter enormously for sustained, multi-step tasks like coding. A coding session isn't really one task; it's a chain of small decisions where each decision depends on the ones before it. Cut the chain and the later decisions get worse, even though each individual decision is being made by exactly the same model as before.

The compounding change

The second change was unrelated and, on its own, much more boring: a tweak to the system prompt that made Claude more verbose in certain situations. System prompts are the standing instructions a model receives before any user conversation starts, the "you are a helpful coding assistant, here are the tools available, here's how to use them" preamble. Anthropic adjusts these periodically as they tune behaviour.

This particular adjustment made Claude's responses longer and more explanatory in ways that, in normal operation, would have been a minor stylistic shift. But layered on top of the context bug, it made things worse in two ways. First, longer responses meant more tokens consumed per turn, which meant the trimming logic kicked in sooner and more aggressively. Second, the verbose explanations made the forgetfulness more visible, Claude would explain what it was about to do, do something inconsistent with what it had said two turns earlier, and the inconsistency was now spelled out in plain English instead of being buried in tool calls.

So the verbosity change didn't cause the problem, but it amplified it and changed how it presented. This is a common shape for production incidents: the actual bug is one thing, but a second unrelated change determines whether the bug is invisible, annoying, or a full-blown user revolt.

Where the metaphor breaks

I called extended thinking "the detective's notes" earlier, and that's a useful image for understanding why dropping it hurts. But the metaphor breaks in a specific place worth flagging.

A real detective's notes are for the detective. They're a memory aid. The thinking happens in the detective's head, and the notes are an external record of it.

For an LLM, there's no separate place where the thinking happens. The thinking is the tokens in the thinking block. When those tokens are in the context, the model can build on them. When they're not, the reasoning effectively didn't happen, as far as the next turn is concerned. There's no "head" the thoughts persist in. So dropping the thinking block isn't like a detective losing their notes, it's closer to a detective losing the part of their brain that held last week's case. The reasoning isn't recoverable from somewhere else, because there is no somewhere else.

This is why context management is such a load-bearing part of agent design, and why bugs in it produce symptoms that look like model failure rather than infrastructure failure.

What to watch

Both changes have been reverted, and Claude Code's behaviour should be back to where it was. But I think the more interesting takeaway is structural. As coding agents take on longer tasks, work that spans many turns, many tool calls, many small decisions, the quality of context management becomes as important as the quality of the model. You can have a frontier model and still ship a worse product than a competitor with a smaller model and better context handling. The model is the engine; context management is the transmission.

Watch, over the coming year, for more disclosure from labs about how they handle context trimming, summarisation, and thinking-block preservation across long sessions. It's the part of the stack that's been least discussed publicly, and incidents like this one suggest it's also where a lot of the real engineering happens.

Footnotes and links

Further reading

• [Anthropic, Extended thinking documentation]: how thinking blocks are produced and preserved across turns
• [Anthropic, Claude Code documentation]: tool use and session management in the coding agent
• [Anthropic engineering blog]: postmortems and changelog entries for Claude Code

¶