The Scaffolding Tax: Why Less Prompt Beats More (2026)

In late July 2026, the day after Opus 5 shipped, the creator of Claude Code said something that contradicted almost every piece of prompting advice published in the previous three years.

They had deleted more than 80% of Claude Code's system prompt. Performance on their coding evaluations did not drop.

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

— Boris Cherny, creator of Claude Code

Read that carefully, because it reframes what a system prompt has been all along. It is not a specification. It is a ledger of a previous model's defects — written to patch a version that no longer exists, and re-read on every single call, forever.

That is the scaffolding tax. And by 2026, four independent sources — two competing frontier labs and two research papers — had measured it and reached the same conclusion.

TL;DR: Anthropic deleted 80%+ of Claude Code's system prompt with no eval loss. OpenAI measured leaner prompts at +10-15% eval scores and -41-66% tokens. Two research papers agree: minimal agents beat fully-equipped ones by 32% and 79%, and 162 personas across 2,410 questions produced no accuracy gain. Supply information, not pressure. Build on a workspace that routes context

What Is the Scaffolding Tax?

The scaffolding tax is the recurring cost of instructions a model no longer needs. Every line in a system prompt, rules file, or skill is re-read on every single call, so it consumes tokens, money, and attention forever. It was worth paying when it corrected a real weakness — not once a newer model fixes that weakness natively.

The tax has three components, and only the first one is obvious:

The mechanism is straightforward once stated. Scaffolding is added at a moment when the model genuinely needs it. Models improve on a roughly quarterly cadence. Instructions do not expire on their own. So the gap between what the model needs and what you are still telling it widens with every release you install without an audit.

The Evidence: Four Sources, One Conclusion

The reason to treat this as a finding rather than a vendor opinion is that two competing labs and two research papers arrived at it independently — Anthropic, OpenAI, a persona study, and an agent-scaffolding ablation — using different methods, between 2024 and mid-2026, and all pointing the same direction: less instruction, not more.

Two of these are competitors who do not coordinate on guidance. One is peer-reviewed and one is a preprint. They measure different things — a shipping product's prompt, an eval suite, an agent-component ablation, and a persona study — and they point the same direction.

What the Persona Research Actually Found

The most widely practiced prompting habit in the world — telling a model to "act as an expert" — does not improve accuracy, and the peer-reviewed study that proved it, testing 162 personas across 2,410 factual questions, has been public since 2023.

"When 'A Helpful Assistant' Is Not Really Helpful: Personas in System Prompts Do Not Improve Performances of Large Language Models" by Mingqian Zheng, Jiaxin Pei, Lajanugen Logeswaran, Moontae Lee, and David Jurgens was accepted to Findings of EMNLP 2024. The design is unusually thorough:

• 162 roles, spanning 6 types of interpersonal relationship and 8 domains of expertise
• 2,410 factual questions
• 4 popular model families
• A control condition with no persona at all

The headline result: adding a persona does not improve performance over the control. But the two secondary findings are the ones that should change your behavior.

1. Persona effects are largely random. Gender, type, and domain of the persona all shift accuracy, but not in a direction you can predict or exploit.
2. You cannot search your way out of it. Aggregating the best persona per question does improve accuracy significantly. But automatically identifying which persona will be best "often performs no better than random selection."

That second point is what kills the technique as a practice. Even granting that some persona helps on some question, you have no reliable way to pick it in advance. You are buying a lottery ticket and paying rent on it every call.

Citation capsule. A peer-reviewed study of 162 personas across 2,410 factual questions and four model families found role-prompting produces no accuracy improvement over no persona at all, with per-persona effects the authors describe as "largely random." Personas remain legitimately useful for controlling tone and voice. They were never an accuracy technique; they were a habit that felt like one.

The Measured Cost of Over-Scaffolding

Numbers, not intuitions. Lean prompts beat verbose ones by 41-66% fewer tokens and 10-15% better eval scores, equipping every capability loses to a minimal config by 32% and 79%, and filling a million-token window degrades retrieval on every model measured — the move that feels right, measured.

That third row deserves emphasis because it inverts a marketing message the whole industry has pushed. Chroma's Context Rot report, which tests 18 frontier models, measured retrieval falling as the input grows, and "Lost in the Middle" showed accuracy dropping when the relevant fact sits mid-context. Bigger windows are a real capability for holding material. They are not a memory upgrade, because the retrieval curve bends the wrong way as you fill them.

   WHAT PEOPLE THINK A BIGGER WINDOW BUYS
   ----------------------------------------------------------
   256K  ####################################  "remembers"
   1M    ############################################  "remembers MORE"
WHAT IT ACTUALLY MEASURES (Context Rot, 18 frontier models)
   short ##################################    retrieves reliably
   long  ###########################           retrieval degrades
                                           |- the haystack grows faster than recall


   A bigger window is a bigger haystack, not a better index.

This is the same result the field has been circling since Lost in the Middle (2023) showed accuracy degrades when relevant information sits mid-context, and Chroma's context-rot work extended it across 18 frontier models. See context rot for the mechanism.

The OpenAI figures are worth looking at as a shape rather than a list, because the two lines move in opposite directions — which almost never happens in optimization.

The Hidden Costs Nobody Budgets For

Beyond the prompt itself, three operational habits carry a scaffolding tax that almost no one measures: delegating to Claude Code agent teams, which can run roughly 7x the tokens of a standard session (sub-agents inside one session cost less); switching models mid-conversation; and capitalizing a rule the model keeps ignoring. In each case the intuitive move is the expensive one.

Delegating to sub-agents to "keep the main context clean." This is the most repeated agent tip of the last two years, and it is only half right. Each delegated agent runs as a separate instance with its own context window, re-paid uncached — which is why Anthropic's documentation puts agent-team sessions at roughly 7x the tokens of a standard session. The useful distinction: sub-agents are cheap for looking (broad search, parallel investigation, little context required) and expensive for doing (anything that needs the context you already have loaded).

Switching to a cheaper model mid-conversation. Prompt caches are per-model. Switch 100,000 tokens into a conversation and you pay to rebuild the cache on the cheap model, then pay again to rebuild it when you switch back. The "cheaper" model can cost more than staying put.

Capitalizing a rule the model keeps ignoring. If a written rule is being violated, the usual cause is that the file is long enough for the rule to be lost mid-context. Emphasis does not fix position. Deletion does.

The unifying mechanism is that most AI costs are paid per call, forever, while most AI decisions are made once. That asymmetry is what makes an unreviewed prompt file expensive.

Why the Rules Inverted

Two mechanisms explain the entire shift, and neither is mysterious: models absorbed the behaviors prompts used to force, so an old patch becomes overhead the moment the gap closes, and reasoning models spend tokens reconciling any two rules that disagree — which is why OpenAI's 2026 guidance drops absolutes like "always" and "never."

Mechanism 1: models absorbed the behaviors prompts used to force. Chain-of-thought instructions existed because models did not reason step by step on their own. Formatting rules existed because output was unreliable. Persona framing existed as a crude way to steer register. Each was a genuine patch for a genuine gap, and each gap closed. When the gap closes, the patch does not become neutral. It becomes overhead that competes with your actual request.

Mechanism 2: contradictions are expensive on reasoning models. OpenAI's 2026 guidance is explicit that conflicting rules cause the model to spend reasoning tokens reconciling the contradiction rather than selecting an action. This is why absolutes like "always" and "never" made their trim list. A long instruction file almost always contains rules that disagree at the edges, and every disagreement is billed.

The Ablation Method: Find Out What Your Prompt Is Worth

An ablation is an evaluation where you delete things to measure their impact. It is standard research practice, and Anthropic applies it to Claude Code's system prompt every time a new model ships — deleting it entirely, then restoring only the lines that prove necessary, one at a time.

"You delete the entire system prompt and then you bring it back line by line to figure out what is the impact of each individual line."

The rule that stops the prompt regrowing is the important half:

"Only when you see it repeatedly stumble on the same thing, that's when you add it back."

Once is noise. Twice is a line item. Most instructions in most files were written after a single bad output.

The advice given to people who merely use these tools rather than build on them was blunter: delete your instruction files, skills, and hooks roughly every six months and see what happens. The prediction is that it will surprise you, because the file was written for a model that has since been replaced twice.

What to Delete and What to Keep

This is the practical core, and it is where the simple version of the advice ("delete everything") needs a correction practitioners found within days: a fixed model can swing 6x in benchmark results from the harness alone, so what you delete matters as much as whether you delete.

Context routing is not instruction. Telling a model where your client notes live is information it cannot derive. Telling a capable model what order to do its work in is a procedure it already knows. The first is a map. The second is backseat driving.

   DELETE (a past model's defects)          KEEP (what it cannot derive)
   ==============================           ===============================
   "you are a senior copywriter"            where the source files live
   "take a deep breath"                     what "done" looks like
   "do step 1, then 2, then 3"              what to verify before finishing
   "always" / "never" absolutes             hard constraints and limits
   "do not return markdown"                 the schema, enforced not asked
   style rules with no measured effect      who approves, and when
   workarounds for a retired model          house facts: brand, legal, policy
   ==============================           ===============================
   These correct a model.                   These inform a model.
   They expire.                             They compound.

The same split explains a result that otherwise looks contradictory. Research has measured a 6x swing in benchmark results from changing only the harness around a fixed model, while Anthropic simultaneously deleted 80% of a harness's prompt and lost nothing. Both are true, because a harness has two halves that age in opposite directions.

The confirming detail: asked what remained in Claude Code's harness after the deletions, the answer was "almost all of it is about safety and permissions and static analysis, and there's a bunch of UI code." The structural half survived. The instruction half was the 80%.

For the fuller treatment of that split, see what an AI agent harness is.

The Verification Ladder

If the instruction half decays, what should you spend that effort on instead? Both the creator of Claude Code and Anthropic's own power-user guidance name the same answer independently: verification, checked at one of four escalating levels, because a 30-step agent run at 95% per-step accuracy finishes correctly only 21% of the time.

"The verification I think is probably the single most important thing that people do not get right."

Anthropic's guidance puts it just as bluntly: the single most impactful practice is verification, because without a check, you are the verification loop, and every error simply waits for a human to notice it.

There are four levels, and they escalate in cost and reliability.

   LEVEL 4  ADVERSARIAL REVIEW AGENT
            a separate agent whose job is to find gaps
            ! scope it to "correctness / stated requirements /
              the done-condition, treat the rest as optional"
              or it will invent problems indefinitely
            ^
   LEVEL 3  BLOCKING HOOK
            a script that physically prevents the turn from
            ending until it passes
            ^
   LEVEL 2  SEPARATE EVALUATOR
            re-checks a condition after every turn
            ^
   LEVEL 1  IN-PROMPT CHECK
            "before you finish, verify X against Y"
            ^
   LEVEL 0  YOU
            every error waits for a human to notice it

The Level 4 caveat is the non-obvious part and worth internalizing: an adversarial reviewer with an open brief always finds something, because that is what you asked for. Scope it to the done-condition or it manufactures work forever.

The reason verification is the right investment is arithmetic. Agent runs multiply their per-step accuracy: a 30-step run at 99% per-step accuracy finishes correctly 74% of the time, and at 95% per step the same run finishes 21% of the time. A verifier does not raise per-step accuracy. It catches the bad step before it propagates into the next ten. See AI yield for the full math.

The Three-Part Prompt That Replaces the Persona

If you delete the persona line and the pressure phrases, you free up roughly the same word budget you started with. Anthropic's own prompting guidance suggests spending it on three things instead: where to look, the definition of done, and a self-check — plus one rule: state what to do, not what to avoid.

1. Where to look — point at the context it should go and get
2. Definition of done — what the finished output looks like
3. A self-check — the docs' own suggested phrasing is "Before you finish, verify your answer against..."

Plus one negative rule: stop writing "do not do X." A prohibition that conflicts with the actual request confuses the model. State the positive form.

Same word count. Every word now doing work. This is the same lesson the history of prompt engineering arrives at from the other direction: techniques that supply information survived, and techniques that supply pressure did not.

Where This Does NOT Apply

An honest article has to mark its own limits, and this thesis has four: context routing is exempt, weaker and smaller models still need scaffolding, product behavior is not raw capability — Anthropic kept roughly 20% of its own prompt on purpose — and the underlying research has its own boundaries.

1. Context routing is exempt. Covered above, but worth restating because the popular version of this advice drops it. Facts a model cannot derive — where things live, your brand rules, your legal constraints, your schema — are not scaffolding. They are inputs.

2. Weaker and smaller models still need scaffolding. The evidence above is about frontier models. If you run a small local model, a cheap tier, or an older snapshot, the instructions you would delete may still be load-bearing. The tax exists because the model outgrew the instruction, and that has not happened everywhere.

3. Product behavior is not raw capability. Anthropic kept roughly 20% of the prompt on purpose. The deleted portion made the model smarter; the retained portion makes the product behave like a product. If you ship something to other people, some instruction exists to make the experience consistent rather than to make the model capable. That part does not get ablated away.

4. The research has boundaries. The persona study measured factual accuracy, not tone, creativity, or safety, and personas remain a legitimate tool for voice. The agent-scaffolding paper found optimal component counts vary by task, which makes "use fewer components" a prior rather than a rule. And "minimal beats maximal" is a finding about the all-in default, not a proof that one component is always right.

The reasonable posture is not minimalism as an ideology. It is: stop treating additions as free, and start measuring what each one buys.

What This Means If You Are Not a Developer

The scaffolding tax is usually discussed as a coding problem because that is where it was measured, but the underlying principle applies to anyone running AI on real work. The durable layer was never an instruction file — it is where your information lives and how it gets checked, and that changes what you should build.

That distinction is the whole design of a Taskade workspace. Projects hold the data. AI agents read those projects rather than a document describing them. Automations act on what the agents decide and write the results back. Nothing in that loop is a procedure written to correct a model's behavior, which is precisely why none of it expires when the model improves.

The practical consequence for a non-coder is short: stop writing longer prompts, and start putting the facts somewhere the agent can read them. A workspace where the answer already lives beats a prompt that restates the answer, on every model, forever.

Start from a working setup in the Community Gallery, or describe the outcome and let Taskade Genesis assemble the projects, agents, and automations together.

Run Your Own Ablation This Week

A concrete 30-minute version of the ablation method for whatever AI tool you actually use: copy your current instructions, cut everything except hard constraints, work with it for a few real tasks, log every failure verbatim, and restore only the lines that fail twice.

Two things to check while you are in there, both of which are pure tax:

• Rules the model keeps ignoring. If a rule is violated despite being written down, the file is probably too long and the rule is lost mid-context. Shortening the file works; capitalizing the rule does not.
• Contradictions. Any two rules that disagree at the edges are billed to you in reasoning tokens on every call. Pick one.

Frequently Asked Questions

Related Reading

• What Is an AI Agent Harness? — the two halves of a harness and why only one ages well
• The History of Prompt Engineering — magic words to context engineering, with a verdict on every old trick
• The Bitter Lesson Explained — Sutton's argument that built-in human knowledge loses to methods that scale
• Types of Memory in AI Agents — episodic, semantic, and working memory in production
• AI Yield — why per-step accuracy decides whether long runs finish
• Context Engineering for Teams — making the window carry your team's reality
• The 21 Agentic Design Patterns — generate-and-test, reflection, and the rest
• AI Agent Error Recovery — what agents do when the world disagrees with them
• What Is Agentic Engineering? — the shift in how software gets built
• How Do Large Language Models Work? — transformers from attention to generation
• How LLMs Got Hands — the history of tool use and function calling
• The History of AI Agents — SHRDLU to the modern agent loop
• Train AI Agents on Your Living Knowledge — the practical version of context routing
• Context Rot — why long inputs degrade non-uniformly
• Retrieval-Augmented Generation — loading context on demand instead of pre-stuffing it
• Structured Outputs — enforcing format at the boundary instead of asking in prose
• Agent Evaluation — how to measure whether a change actually helped

🧬 Before you go... The instructions expire. The workspace does not. Taskade Genesis turns one prompt into projects that hold your data, AI agents that read them, and automations that act and write the results back. Context routing instead of instruction, which is the half that survives every model upgrade.

• 🚀 AI App Builder: Describe an outcome, get a working app with data, agents, and automations wired together.
• 🤖 Custom AI Agents: Agents with tools, slash commands, and persistent memory, grounded in your projects.
• 🔄 Automations: 100+ bidirectional integrations that run the check and record the result.
• 🧬 Workspace DNA: Memory feeds Intelligence. Intelligence triggers Execution. Execution creates Memory.

Start free

Resources

1. When "A Helpful Assistant" Is Not Really Helpful — Zheng, Pei, Logeswaran, Lee & Jurgens, Findings of EMNLP 2024
2. More Is Not Always Better: Cross-Component Interference in LLM Agent Scaffolding — Ming Liu, May 2026
3. OpenAI's prompting guidance, reported July 13, 2026
4. Lost in the Middle: How Language Models Use Long Contexts — Liu et al., 2023
5. Context Rot — Chroma technical report
6. Boris Cherny: We Cut 80% of Claude Code's Prompt

▲ ■ ● Memory. Intelligence. Execution. Route the context; delete the lecture.