Do CLAUDE.md and AGENTS.md files actually improve coding agent results?

On the evidence published so far, they do not measurably improve correctness. A July 28, 2026 ablation ran 288 evaluated runs across Claude Code and Codex on 17 real tasks from 3 repositories and found context strategy did not move correctness on either agent, bounding any effect to roughly 10-15 percentage points or less. An earlier study from ETH Zurich reached the same conclusion across multiple models and agents, and added a cost figure: context files increased inference cost by over 20% on average with no matching gain. Both studies did find that agents follow the instructions in the files. So the files change what the agent does; they just don't make it more capable.

Should I delete my CLAUDE.md file?

Not wholesale — but you should test it rather than trust it. Keep the parts that carry facts the agent cannot infer from the repository: the build and test commands, deploy steps, conventions with no in-repo signal, and hard prohibitions. Delete the parts that try to make the agent smarter: general coding advice, restatements of good practice, and workarounds written for an older, weaker model. Claude Code's creator recommends that users delete their CLAUDE.md, skills and hooks roughly every six months and see what the model does without them, then add back only the lines the model repeatedly stumbles without. Every line you keep is re-read on every single request, so it has to earn that.

Anthropic deleted 80% of Claude Code's system prompt and it got better — what that means for your CLAUDE.md

Q: Does this research prove context files do nothing?

No, and the distinction matters. The July 2026 study reports a bounded null result: with 288 runs across 17 tasks it can rule out effects larger than about 10-15 percentage points, not effects smaller than that. A real but modest benefit would be invisible at that sample size. The study also found the failure mode is implementation skill — feature design, pattern selection, exact wiring — rather than missing repository knowledge, which is a claim about why context files don't help on these tasks, not a claim that they never help on any task. What is well supported is the negative version: writing more rules will not raise your agent's success rate, and it will cost you tokens on every request.

Q: If the model isn't the bottleneck, what is?

The harness around it — the scaffolding, the defaults, and the spending controls. The same week the prompt-deletion story broke, an open-source harness published measurements showing it renders its first frame in 14 milliseconds against Claude Code's 3,436, using 27.8 MB of RAM per session against 386.6 MB, while calling the same frontier models. Amazon, meanwhile, was reported to have spent $1.8 million on a single Claude-powered task that ran 860% over budget and never shipped, undetected for five months. And Claude Code quietly changed a default: the built-in Explore subagent now inherits your session model instead of running on Haiku. None of those outcomes is a model quality problem. All of them are decided by the wrapper.

On July 27, the person who built Claude Code said his team had deleted more than 80% of its system prompt for the Opus 5 release — and that the agent got better without it.

The next day, a paper landed that tested the same idea from the outside: 288 evaluated runs, two frontier agents, real repositories, asking whether the CLAUDE.md and AGENTS.md files everyone maintains actually change the outcome. The measured answer was no.

This site has published nine articles about writing good CLAUDE.md files. So this is the uncomfortable kind of evidence, which is exactly why it’s worth reading carefully rather than reacting to the headline. The finding is narrower than “delete your CLAUDE.md,” and the part that survives is the part worth knowing. Sources are at the end.

The 30-second version

Anthropic deleted its own scaffolding and shipped the result. Claude Code’s creator, July 27: over 80% of the system prompt removed for Opus 5, agent performs better. The deleted lines weren’t wrong — they were patches for behaviors older models got wrong and Opus 5 now does unprompted.
An independent ablation measured no correctness gain from context files. 288 runs, Claude Code and Codex, 17 real tasks across 3 repositories. Effect bounded to 10–15 percentage points or less — meaning: nothing detectable at that sample size.
An earlier study found the same thing, and priced it. Across multiple models and agents, context files raised inference cost over 20% on average with no matching success-rate gain. Repository overviews specifically — the thing model vendors recommend — were not helpful.
But agents do obey the files. Both studies found instruction-following works. That’s the whole distinction: a context file is an obedience tool, not an intelligence tool. It changes what the agent does. It doesn’t make it better at doing it.
The bottleneck moved to the harness. One open-source wrapper renders its first frame in 14 ms against Claude Code’s 3,437 ms, on the same models. Amazon burned $1.8M on one task at 860% over budget, undetected for five months. Same models, wildly different outcomes.
What to actually do: stop writing rules to make the agent smarter. Keep the facts it can’t infer. Use Anthropic’s own method — delete everything, add back line by line, keep only what the model repeatedly stumbles without.

What Anthropic actually deleted, and why

The claim comes from Boris Cherny, who created Claude Code, on a July 27 podcast. When Opus 5 shipped, his team stripped more than 80% of the agent’s system prompt, and the agent came out ahead.

His reasoning is the important part, because it isn’t “instructions are bad.” It’s that most of those instructions had a shelf life:

“A lot of the stuff in the system prompt was correcting for these behaviors that the model should have known, but it didn’t. Now Opus 5 just does it.”

Those lines were written against a weaker model. They were correct when written. They became dead weight the moment the model internalized the behavior — and worse than dead weight, because a system prompt is re-read on every single request. Cherny’s word for the failure mode is hobbling: the model is trying to do the right thing and your instructions are in the way.

The method his team uses to find those lines is worth stealing. It’s a straight ablation: delete the entire prompt, then add lines back one at a time, measuring what each one is actually worth. Not “review the prompt and trim what looks stale” — delete first, and make every line re-earn its place.

And he extends it explicitly to people who use Claude Code rather than build agents: roughly every six months, delete your CLAUDE.md, your skills and your hooks, run without them, and see what the model does. Add back only what the model repeatedly stumbles without. His argument against adding rules speculatively is a cost argument as much as a quality one — the model reads that instruction on every use, forever.

Two studies, 288 runs, and a 20% cost premium

The day after that interview, a paper tested the user-side version of the same question.

The setup: a controlled ablation of context-injection strategy across two frontier agents (Claude Code and Codex), 17 real tasks from 3 repositories (15 shared, 2 Codex-only), 288 evaluated runs, scored against gold tests rather than a model judge. The result:

Context strategy does not measurably move correctness on either agent (bounded to ≤10–15pp via equivalence testing).

Two details make this stronger than a null result usually is. First, the failure triage: agents failed on implementation skill — feature design, pattern selection, exact wiring — not on missing repository knowledge that a file could have supplied. Second, a manipulation probe: the real context file never converted a near-miss into a pass on either agent. If context files were doing work, the near-misses are exactly where you’d see it.

This is not the first study to land here. A team at ETH Zurich published the same conclusion in February, revised in June, across multiple models and agents and with both AI-generated and real developer-committed files:

Providing context files does not generally improve task success rates, while increasing inference cost by over 20% on average.

They singled out the format vendors recommend most: repository overviews, “although popular and recommended by model providers, are not helpful.”

That 20% is the number to sit with. It isn’t neutral. A file that doesn’t help but costs a fifth more on every request is a standing tax — and it compounds exactly the way Claude Code’s baseline token overhead does.

What this does and doesn’t prove

Here’s where most coverage of these papers will go wrong, so it’s worth being precise.

It is a bounded null, not a zero. With 288 runs across 17 tasks, equivalence testing can rule out effects larger than roughly 10–15 percentage points. It cannot rule out a real 3-point gain. If your honest expectation was “my CLAUDE.md makes the agent a bit more consistent,” this study does not refute you — it refutes the belief that context files are a large lever.

The sample is small and specific. Three repositories, 17 tasks. The newer paper is candid that prior evidence on this question is contradictory, and its own contribution is partly explaining why: whether a task sits near the pass/fail boundary is agent-specific, so studies that don’t screen tasks per agent end up measuring in a range where nothing can move. That’s a methodological caution about all such studies, including this one.

And the finding everyone will skip: the files are obeyed. The ETH study explicitly found agents follow the instructions inside context files. Nothing here says the agent ignores your file. It says compliance doesn’t convert into correctness.

Which gives the actual rule, and it’s sharper than the headline:

A context file reliably changes what your agent does. It does not make your agent better at doing it.

So the lines that pay are the ones where compliance is the goal — a fact the agent cannot derive from the repository, and would otherwise guess wrong:

The build, test and deploy commands that aren’t discoverable from the tree
Conventions with no in-repo signal (“we use X, never Y” where both appear in history)
Hard prohibitions — the paths, branches and credentials it must not touch
Anything where being wrong is expensive and the repo doesn’t say

The lines that don’t pay are the ones written to raise capability: general coding advice, restatements of good practice the model already has, tone instructions, and — the big one — workarounds for a model you no longer run. That last category is invisible until you look for it, and it’s the same category Anthropic just deleted 80% of. The size-versus-performance question turns out to have a blunter answer than “how long is too long”: length is the wrong axis, and provenance is the right one.

The bottleneck moved to the harness

Zoom out and the week has one theme: with the model this good, the wrapper is where outcomes are decided.

Speed and footprint. An open-source MIT-licensed harness called jcode published a comparison against Claude Code while calling the same frontier models: first frame in 14.0 ms versus 3,436.9 ms (about 245×), 27.8 MB of RAM for one session versus 386.6 MB, and about 9.9 MB versus 212.7 MB for each additional session. Whatever you think of one project’s self-reported benchmarks, the direction is the point: identical model, two orders of magnitude of difference in what the shell around it costs you.

Money. Leaked Amazon documents reported this week describe a single Claude-powered task — matching author details to product listings — that ran $1.8 million, 860% over budget, and never launched. It went five months undetected. Two more overruns (~$541K on a financial auditing tool, $134K on a logistics system) brought unplanned spend to about $2.5 million. The most telling detail isn’t the number, it’s the incentive: Amazon had pushed for 80%+ of developers to use AI tools weekly, and staff reportedly assigned agents to unnecessary work to climb an internal leaderboard — a practice they called tokenmaxxing. The leaderboard has since been retired. No part of that is a model quality failure. It’s governance around the harness, which is the same lesson as the agent-teams cost verdict, at company scale.

Defaults that move silently. Claude Code’s built-in Explore subagent used to run on Haiku. It now inherits your session model, capped at Opus — and subagents inherit your extended-thinking configuration too. That is a real quality improvement and a real bill increase, and for a while the docs still said Haiku. If you sized your subagent budget on “Explore is cheap,” it isn’t anymore. Fan-out multiplies whatever the default is, so a default change is a budget change.

What to actually do

Run the ablation on your own file. Rename CLAUDE.md to CLAUDE.md.bak, work for a day, and notice what actually breaks. Most people have never seen their agent without the file and are defending something they haven’t tested. Add back only the lines whose absence you felt.

Sort your file by provenance, not by length. For each line ask: is this a fact about my project, or a correction aimed at a model? Facts stay. Corrections get deleted and only come back after the model stumbles on the same thing twice. Anything written before your current model shipped is a suspect by default.

Stop expecting the file to raise your success rate. If your agent is failing on feature design, pattern selection, or wiring things together correctly, that’s the failure mode both studies identified — and no amount of repository documentation addresses it. That’s a job for smaller tasks, better tests, and review, not for more prose.

Budget the file as a standing cost. It’s re-read on every request. At the measured 20% inference premium, a bloated context file is one of the few costs that scales with everything you do, which is why it deserves the same scrutiny as the rest of your context window.

The larger pattern is the one Cherny named: products built for last year’s models keep last year’s guardrails, and those guardrails become the ceiling. That applies to Anthropic’s system prompt, and it applies to the file in your repo root. Opus 5 arrived a week ago. Most CLAUDE.md files in production were written against a model two or three generations back, and have only ever been added to.

Companion reading

Claude Code’s token overhead — the baseline cost your context file sits on top of
How to write a CLAUDE.md — the practical guide, now read it with the obedience-not-intelligence distinction in mind
How big can a CLAUDE.md get before it hurts — the length question this research reframes as a provenance question
Claude Code context management — what else is competing for the same window
Opus 5 vs Fable 5 — the model whose arrival triggered the 80% deletion

Sources

FAQ

Did Anthropic really delete 80% of Claude Code’s system prompt? Yes. Boris Cherny, who created Claude Code, said on a July 27, 2026 podcast that his team removed more than 80% of the system prompt when Opus 5 shipped, and the agent performed better afterwards. His explanation: those lines weren’t wrong, they were corrections for behaviors older models got wrong and Opus 5 now does on its own. The method is ablation — delete the whole prompt, add lines back one at a time, and measure what each is worth.

Do CLAUDE.md and AGENTS.md files actually improve results? Not correctness, on the published evidence. A July 28 ablation — 288 runs, Claude Code and Codex, 17 real tasks across 3 repositories — found context strategy did not move correctness on either agent, bounding any effect to roughly 10–15 percentage points or less. An earlier ETH Zurich study reached the same conclusion across multiple models and agents and priced it: over 20% more inference cost, no matching gain. Both found agents do follow the instructions. The files change what the agent does; they don’t make it more capable.

Should I delete my CLAUDE.md? Test it rather than trust it. Keep facts the agent can’t infer — build and test commands, deploy steps, conventions with no in-repo signal, hard prohibitions. Delete the parts written to make it smarter: general coding advice, restated best practice, and workarounds for a model you no longer run. Claude Code’s creator suggests deleting your CLAUDE.md, skills and hooks about every six months, running without them, and adding back only what the model repeatedly stumbles without. Every surviving line is re-read on every request.

Does this prove context files do nothing? No. It’s a bounded null: 288 runs across 17 tasks can rule out effects larger than about 10–15 points, not smaller ones, so a modest real benefit would be invisible here. The study also attributes failures to implementation skill — feature design, pattern selection, wiring — rather than missing repository knowledge, which explains why files didn’t help on these tasks. What’s well supported is the negative claim: more rules won’t raise your success rate, and they cost tokens on every request.

If the model isn’t the bottleneck, what is? The harness. In the same week, an open-source wrapper reported a 14 ms first frame against Claude Code’s 3,437 ms and 27.8 MB per session against 386.6 MB, calling the same models; Amazon was reported to have spent $1.8M on one task at 860% over budget, unnoticed for five months; and Claude Code’s Explore subagent quietly switched from Haiku to inheriting your session model. None of those is a model quality problem — all of them are decided by the wrapper and its defaults.