The Rules That Survive: Auditing My Context Stack for Claude 5

By Thorsten Meyer

Anthropic deleted more than 80 percent of Claude Code’s system prompt for its newest models — Opus 5 and Fable 5 — and measured no loss on its coding evaluations.

That number did not land for me as a product announcement. It landed as an audit notice.

I run 477 WordPress properties, four or five active codebases, a defense-ISR product line, and an editorial pipeline with a format standard strict enough that I can describe it in a single paragraph and expect a four-file package back. Every one of those is a CLAUDE.md, a skill file, or a house rule I wrote down so I would not have to say it again.

Most of those rules were written for a generation of models that has now passed.

The uncomfortable part is not that the guidance was wrong. It is that it was right, and the trade changed underneath it.

What actually changed

Thariq Shihipar's post from Claude Code lays out six shifts. Paraphrased, they run like this.

Rules became judgement. Early Claude Code shipped hard prohibitions — no comments, no multi-line docstrings, no planning files unless asked — because the worst case was worse than the average case. Newer models read surrounding code and match its density and idiom instead. The instruction became descriptive rather than prohibitive.

Examples became interface design. The old first rule of tool use was: show the model examples. Anthropic now finds that examples narrow the exploration space. A well-typed enum in a tool schema communicates intended behaviour more cleanly than three worked cases.

Front-loading became progressive disclosure. Verification and code review left the system prompt and became skills the model calls when relevant. Some tools are deferred — their full definitions are fetched only on demand, so a large tool surface costs nothing until it is used.

Repetition became a single authoritative description. Older models sometimes needed an instruction at the top of context and again at the bottom. That duplication is now removable; the tool description is the canonical place.

Manual memory became automatic memory. The # hotkey habit of writing everything into CLAUDE.md is superseded. CLAUDE.md was never meant to be a diary.

Simple specs became rich references. A markdown description of a design is a lossy encoding of the design. An HTML mockup, a test suite, a function in another codebase to port, or a rubric a verifier agent can apply — all of these are higher-fidelity than prose about them.

There is a shipped command behind the advice. /doctor in Claude Code inspects your skills and CLAUDE.md files and helps rightsize them.

The AI Prompt Playbook: Master AI Prompt Engineering with 140 Ready-to-Use Templates for ChatGPT, Claude, Gemini & Copilot

View Latest Price

As an affiliate, we earn on qualifying purchases.

As an affiliate, we earn on qualifying purchases.

The one test

Strip the six shifts down and there is a single question underneath all of them:

Would a strong model behave worse without this line?

If the answer is no, the line is scaffolding. It was holding up something that now stands on its own, and it is costing you tokens plus — more expensively — reasoning cycles spent adjudicating between your rule and someone else's.

That second cost is the one people miss. Anthropic's own diagnosis was that their transcripts contained instructions actively fighting each other: leave documentation where appropriate, sitting a few hundred tokens away from an all-caps ban on comments. The model resolves the contradiction before it does the work. You pay for the resolution every single request, on every request, forever.

If the answer is yes, the line is non-derivable — it encodes something the model cannot see from your repository, your file system, or the code in front of it. Those survive.

Running the test on my own stack

I did this honestly, which meant deleting more than I expected.

Non-derivable. Kept.

• PIL does not decode HTML entities. Featured-image generation uses a plain ampersand, never the escaped form. Nothing in the codebase reveals this; you learn it by shipping a JPEG with & burned into the headline.
• Self-hosted fonts only, no Google CDN. This is a DSGVO posture for German-market properties, not a performance preference. A model optimising for load time would reach for the CDN and be wrong.
• All infographic CSS scoped under one unique wrapper class, custom properties namespaced. This exists because a global selector inside a WordPress Custom HTML block turns the entire page background dark. That is a deployment-environment fact, invisible from the file.
• Rannsaka never sends document content to a hosted endpoint. That is a client-confidentiality rule, and it is exactly the kind of hard constraint the post says to keep.
• pricing.ts is the single source of truth, and no plan uses -1 to mean unlimited. Both are scar tissue from real bugs.

Scaffolding. Deleted.

• Long tone prescriptions in the editorial skill. Short paragraphs, sparing emphasis, no hype verdicts — the model already produces this given two paragraphs of context and a previously shipped piece. I was restating taste it had already learned.
• Stack declarations. Next.js 15, TypeScript strict, PostgreSQL with Drizzle — all of this is visible in package.json in under a second. Writing it in CLAUDE.md told the model nothing and cost me tokens on every session.
• Duplicated queue instructions. SELECT … FOR UPDATE SKIP LOCKED appeared in the system context and in the job-runner documentation. One copy now, in the place it belongs.

Moved, not deleted.

The four-file editorial package specification was 200-odd lines sitting in always-loaded context. It is now a skill with a pointer, and the pointer is one line. Infographic conventions, PIL gotchas, and image specifications are separate files inside it, loaded when an infographic is actually being built rather than when I ask a question about EU chip policy.

Converted to references.

This was the largest win, and I nearly missed it. I had been describing the AI-Dispatch infographic style in prose — warm paper, violet accent, dark rail, amber safety signal, eyebrow banner. Every description is an approximation.

I now point at a shipped .html file instead. The style is not a paragraph about the style; it is the artifact. Roughly forty lines of guidance collapsed into one @ mention, and the fidelity went up, not down.

The part that does not travel

Here is where I part company with the enthusiasm, and it matters for anyone building the way I build.

This is frontier-model advice.

I target 70 to 90 percent local inference. The DojoClaw fleet runs Qwen3 235B at six-bit on the M3 Ultra and a 32B MLX build as the daily driver. The guardrails Anthropic just deleted are precisely the guardrails a 32-billion-parameter open-weight model still needs. Unhobbling is a capability dividend, and it does not pay out evenly across your inference stack.

The practical consequence is that I now maintain two context regimes, not one. Lean context for hosted frontier work, structured context with explicit rules for local runs. Whether the shared portion can stay shared is an open question in my setup, and the post does not price this cost because Anthropic does not have it.

The second concern is governance rather than tokens. When you move behaviour from your written rules into the model's judgement, your effective policy becomes whatever the current model thinks is appropriate. That is fine — until the model changes. For a publisher with a house style across hundreds of properties, "the model has good taste now" is a dependency, not a solution. Rules are also documentation for humans; they survive model upgrades, and they can be diffed.

The steelman for keeping more than the post suggests is straightforward: consistency at scale is not the same problem as correctness on a single task. A rule that a strong model would have followed 90 percent of the time anyway is still worth writing down if the other 10 percent ships to production under my byline.

Anthropic's answer, implicitly, is to test it — delete the rule, run your evals, and see whether the score holds. That is the right method. It also assumes you have evals, which most publishers and most small builders do not.

What I am doing this week

The sequence, in the order that works:

1. Run /doctor across the active repositories for a first pass.
2. Grep every CLAUDE.md and skill file for NEVER, ALWAYS, DO NOT, and all-caps prohibitions. Apply the one test line by line.
3. Sort survivors into keep (non-derivable: legal, deployment, client-confidentiality, hard-won gotchas) and move (real but situational — extract to a skill, leave a pointer).
4. Replace every prose description of a visual or structural standard with the shipped artifact itself.
5. Keep a separate, more explicit context file for local-model runs, and stop pretending one set of instructions serves both.

I expect to delete more than half of what is currently loaded on every request. My earlier guidance was not mistaken — it was calibrated to models that needed it. That distinction is worth making out loud, because the alternative is quietly rewriting your own history every time the frontier moves.

The rules that survive this cut are the ones that encode something the world taught me and the repository cannot show. Everything else was a splint on a leg that healed.

Sources: Thariq Shihipar, "The new rules of context engineering for Claude 5 generation models," Claude by Anthropic blog, 24 July 2026; Anthropic Claude Code documentation; contemporaneous coverage in Techstrong.ai and Developers Digest, late July 2026. Portfolio details and conventions are my own. Point-in-time as of 3 August 2026.