Over 80%. That is how much of Claude Code's system prompt Anthropic deleted for its Claude 5 generation models — Claude Opus 5 and Claude Fable 5. The result: no measurable loss on coding evaluations.
In a post published July 24, Thariq Shihipar, a member of Anthropic's technical staff, walked through the rewrite in unflinching detail. The company that built the most sophisticated coding agent harness in production looked at its own system prompt, decided it was doing more harm than good, and gutted it.
This is not a minor optimization. It is the most authoritative confirmation yet that the context engineering playbook — the entire discipline of layering rules, examples, and behavioral constraints into agent scaffolding — has a shelf life. And that shelf life is expiring.
The Problem With Too Much Context
Two weeks ago, I wrote about wire-level analysis showing Claude Code sending 33,000 tokens before reading a single character of user input. The task was 22 characters: "Reply with exactly: OK." The harness payload was 1,500 times larger than the task itself.
The response from the community was predictable: the prompt bloat must be intentional, carefully engineered, and load-bearing. Surely Anthropic wouldn't ship 27,000 characters of system prompt if they weren't all necessary.
It turns out they weren't. Or more precisely — they were necessary for older models and actively counterproductive for newer ones.
Anthropic's own diagnosis was brutal. When they read transcripts of internal Claude Code usage, they found conflicting messages within a single request. The system prompt said "leave documentation as appropriate." A skill said "DO NOT add comments." The user said something else entirely. Claude could resolve the conflict, but it had to burn reasoning cycles doing so — thinking carefully about overlapping and contradictory instructions before deciding what to do.
Every constraint you add to a system prompt is a tax on every inference. For models that needed guardrails to avoid pathological behavior, the tax was worth paying. For models that don't, it's pure overhead — a constant cognitive drag that slows down every interaction without improving any outcome.
Five Inversions That Just Happened
Anthropic documented five paradigm shifts in how they engineer context for Claude 5 models. Each one is a direct refutation of a practice that was considered best-in-class eighteen months ago.
1. Rules became judgement. The old system prompt said: "default to writing no comments. Never write multi-paragraph docstrings or multi-line comment blocks — one short line max." The new prompt says: "Write code that reads like the surrounding code: match its comment density, naming, and idiom." One is a rule. The other is a principle. The model no longer needs the rule because it can infer intent from context.
2. Examples became interface design. Anthropic's previous guidance for tool usage was to provide examples — show the model how to call each tool. They found that examples actually constrain models to a narrow exploration space. Instead of teaching through demonstration, they now design expressive tool interfaces where the parameter schema itself communicates intent. An enumeration of pending, in_progress, and completed tells Claude more about expected behavior than any example would.
3. Upfront became progressive disclosure. Claude Code's system prompt used to include detailed code review and verification procedures — information that was crucial when needed but wasted context on every request where it wasn't. Anthropic moved these into skills that Claude can selectively call. They also introduced deferred tool loading: tools that don't enter context until Claude searches for them via ToolSearch. The harness now has more capabilities than ever, but each request carries only what's relevant.
4. Repetition became simplicity. Earlier Claude models sometimes needed repeated instructions, or were more likely to follow instructions placed at the end of the context window rather than the beginning. Anthropic's system prompt accommodated this by restating tool usage guidance in multiple places. For Claude 5, they deleted every duplicate and consolidated instructions into the tool descriptions themselves.
5. Manual memory became automatic. The old workflow told users to manually save things to CLAUDE.md files using the # hotkey. Claude 5 now automatically saves relevant memories without prompting. Plan files and spec documents — previously stored as markdown for Claude to reference — are being replaced by HTML artifacts and code-based references like detailed test suites. The model can read a function signature in another codebase as a spec more reliably than it can parse a natural-language description.
Why This Matters Beyond Anthropic
You might think this is just a Claude Code optimization. It is not. It is a signal about where the entire agent stack is heading, and every team building agent infrastructure should be paying attention.
Consider the timeline. The context engineering orthodoxy — write detailed rules, provide examples, front-load instructions, repeat critical guidance — was codified during the Claude 3 era. Models needed scaffolding because their base judgement was unreliable. You compensated for model weakness with harness strength.
That compensation came at a cost. Every rule is a constraint the model must check. Every example is a pattern the model anchors to. Every repeated instruction is wasted tokens that crowd out actual task context. The harness was never free — it was a trade between guidance and overhead, and for a long time, the balance favored guidance.
Anthropic just showed that the balance has flipped. Claude 5 models — and by extension, any frontier-class model — have better judgement than the rules designed to constrain them. The scaffolding that was helping is now hurting.
This has implications that reach far beyond prompt engineering.
The Death of the Fat Prompt
For the last two years, the dominant strategy in agent development has been accumulation. Every edge case you encounter gets a new rule in the system prompt. Every tool misuse gets a new example. Every failure mode gets a new constraint. The system prompt grows monotonically — it never shrinks, because removing anything feels risky.
Anthropic just provided the empirical case for subtraction. They removed 80% and lost nothing. That means at least 80% of their accumulated context engineering was dead weight — rules that constrained without helping, examples that narrowed without guiding, repetition that occupied context without improving outcomes.
If your agent harness has been accumulating context engineering over multiple model upgrades, you are almost certainly carrying the same dead weight. The question is not whether you can afford to delete it. The question is whether you can afford not to.
The economics are straightforward. Every token in your system prompt is sent on every single request. If you're running 10,000 agent interactions per day and your system prompt carries 5,000 tokens of unnecessary constraints, you're paying for 50 million wasted tokens daily. At frontier-model pricing, that is real money. And it's not just cost — those tokens consume context window that could hold task-relevant information, and they add latency to every inference.
The Progressive Disclosure Inflection
The most architecturally significant shift is progressive disclosure. Anthropic moved from loading everything upfront to loading context on demand — skills that activate when needed, tools that load via search, memory that saves automatically.
This is not a prompt optimization. It is a re-architecture of how context flows through an agent system. And it mirrors what is happening across the open-source ecosystem.
Poolside released Laguna S 2.1 on July 24 — an 118-billion-parameter mixture-of-experts model with 8B activated parameters, 256 routed experts, and a 1-million-token context window. It scores 78.5% on SWE-bench Multilingual and 59.4% on SWE-bench Pro. The model uses interleaved thinking between tool calls with per-request reasoning control, native tool-calling with a custom chat template, and progressive context management.
The pattern is consistent. Frontier coding models — whether proprietary like Claude 5 or open-weight like Laguna — are being designed to manage their own context progressively. They don't need the harness to front-load every possible instruction. They need the harness to make information available on demand and get out of the way.
This is why the claude doctor command matters. Anthropic built a tool that analyzes your context engineering — your CLAUDE.md files, your skills, your system prompt — and tells you what to cut. They are explicitly telling users that their accumulated context engineering is probably hurting them.
What to Do This Week
If you are building or maintaining an agent harness, here is the immediate action plan.
Audit your system prompt for rules that override model judgement. Every instruction that says "always do X" or "never do Y" is a candidate for deletion. Ask: does the model do the wrong thing without this rule? If you're on a frontier-class model, the answer is increasingly no. Replace rules with principles — "match the surrounding code's conventions" is better than "write no comments."
Move from examples to interface design. If your tool usage instructions include examples of how to call a tool, consider whether the tool's parameter schema could communicate the same information more efficiently. An expressive enum does more work than a demonstration, and it doesn't constrain the model to the patterns you happened to show it.
Implement progressive disclosure. Move contextual instructions out of the system prompt and into skills or files that load on demand. If you have verification procedures, code review guidelines, or domain-specific workflows, don't front-load them. Make them available through the harness's discovery mechanism and let the model decide when they're needed.
Stop repeating yourself. If the same instruction appears in your system prompt, your tool descriptions, and your CLAUDE.md, pick one location. Tool behavior belongs in tool descriptions. Repository context belongs in CLAUDE.md. Product context belongs in the system prompt. Cross-contamination wastes tokens.
Measure before and after. The reason Anthropic could confidently delete 80% is that they had evaluation suites to verify no regression. If you don't have automated tests for your agent's task performance, you're flying blind — you'll never know whether your context engineering is helping or hurting.
The Harness Convergence
There is a broader pattern here that ties together several developments from the past few weeks.
Cloudflare, on July 1, redefined its entire bot taxonomy around behavior rather than identity — separating Search, Agent, and Training traffic. The implicit message: the agent web is now diverse enough that binary "allow or block" decisions are insufficient. Agents need to be classified by what they do, not who they are.
Open-weight coding models like Laguna S 2.1 and the GLM-5.2 family are shipping with native tool-calling, reasoning control, and million-token context windows. They are designed for agent workloads from the architecture up, not retrofitted for them.
And Anthropic — the company with the most production-hardened coding agent in the world — just proved that the optimal amount of system prompt for their best models is a fraction of what they previously shipped.
The convergence is clear: as models get smarter, the optimal harness gets thinner. Not simpler — thinner. The capabilities don't go away. They move from upfront constraints to on-demand resources. The harness becomes a discovery layer, not a doctrine layer.
The teams that internalize this will build faster, cheaper, and more capable agents. The teams that don't will spend the next year adding rules to system prompts that their models no longer need — paying a tax on every interaction for constraints that stopped helping three model generations ago.
The Bottom Line
Context engineering is not dead. But the version of it that says "add more rules, more examples, more upfront guidance" is. What replaces it is harder — designing interfaces that communicate intent through structure, building progressive disclosure systems that load context at the right moment, and trusting model judgement enough to delete the guardrails you spent years building.
The hardest part of harness engineering was always knowing what to remove.