Anthropic Erased 80% of Claude Code's Own System Prompt With No Performance Loss

Anthropic quietly deleted more than 80 percent of the internal system prompt powering Claude Code when it upgraded its toolchain to run on Claude Opus 5 and Claude Fable 5 — and its coding evaluation scores did not move. Now Addy Osmani, the engineer Anthropic recruited from Google to lead Claude Code's developer experience, is arguing that most teams using the tool have accumulated the same kind of dead weight in their own instruction files and should do the same.

Osmani published the guidance on October 29, 2026 under the title "You're probably overprompting Claude," describing what he calls "prompt debt": a buildup of explicit instructions written for earlier, less capable models that now cost inference tokens, crowd out working context, and sometimes actively degrade the behavior of newer ones.

The 80-percent reduction is not an anecdote. Thariq Shihipar, a member of Anthropic's technical staff, confirmed it publicly in July 2026: "We removed over 80% of Claude Code's system prompt for models like Claude Opus 5 and Claude Fable 5 with no measurable loss on our coding evaluations." That means Anthropic applied the principle to its own production tool months before recommending it to users — a stronger validation than a blog post alone provides.

Why Frontier Models Need Fewer Instructions Than Earlier Ones Did

The underlying dynamic is straightforward: modern frontier models have absorbed behaviors through training that older versions required explicit prompting to produce. A developer who built up a CLAUDE.md file in 2024 or early 2025 would have reasonably included instructions covering tone, caution level, code style, self-checking habits, and general task discipline. Claude Opus 5.5, which Anthropic released on September 22, 2026 at a price of $4 per million input tokens and $20 per million output tokens, has internalized many of those defaults.

Feeding those instructions to the model anyway does not reinforce them — it occupies context window space and can interfere with internal reasoning. Like technical debt in software, prompt debt accumulates silently, accrues interest through wasted tokens, and is rarely cleaned up because the original author has moved on.

The economics compound this. Opus 5.5 is already approximately 40 percent cheaper than its predecessor at default inference settings, and teams that strip redundant system-prompt instructions reduce their effective input token cost further while eliminating the risk of instructions overriding model defaults that now serve them well.

The /doctor prompt-audit Command and How to Run a Prompt Cleanup

Anthropic has built the cleanup workflow directly into Claude Code. The /doctor prompt-audit command, added in Claude Code version 2.1.283, analyzes a project's CLAUDE.md file and agent instruction configurations, identifies patterns that were written for older Claude models, and flags instructions that duplicate behaviors the current model already provides by default.

The existence of the command is itself significant. Anthropic treating instruction quality as a first-class developer-tooling problem — rather than leaving it to user intuition — suggests the engineering team views prompt debt as both widespread and serious enough to warrant automated detection.

Osmani suggests a three-stage approach to prompt cleanup: first, delete a substantial portion of accumulated instructions; observe where the model actually falls short on real tasks; then restore only the instructions that address documented gaps. This inverts the usual instinct to accumulate safety-net instructions and replaces it with evidence-driven restoration.

The recommended cadence is quarterly. Every few months, teams should revisit which instructions can be pruned, which tasks have become safe to delegate entirely to the model, and which outputs still require human verification. The /doctor prompt-audit command is designed to make that audit substantially faster than a manual review.

Acceptance Criteria and the /goal Command: How Claude Knows When to Stop

The deeper shift Osmani describes is from instruction-heavy prompting to outcome-specification. Rather than providing Claude with a detailed procedure, the recommended approach for Claude Opus 5.5 is to describe the desired outcome and define a machine-executable condition for evaluating whether it has been achieved.

This functions analogously to test-driven development: a test defines what "done" looks like before implementation begins. When Claude has a clear, executable verification condition — a test suite passing, a specific value reaching a target, a structural check producing no errors — it can iterate autonomously until the condition is met, re-examining its own output after each cycle.

The /goal command implements this at the session level. A user sets a condition, and at the end of each agent loop, a separate model instance evaluates whether the condition is satisfied. This separation of execution and evaluation mirrors a practice common in software testing — the evaluator has no stake in the result and applies the criterion mechanically.

For tasks where the user is still clarifying requirements, Osmani recommends a discovery phase: ask Claude to generate questions until it has enough context to write a requirements specification, then open a new session and give it that specification as its goal. The initial session is discarded; the specification becomes the source of truth for execution.

A complementary practice is to build explicit checkpoint stages into long agent runs — points at which Claude reports preliminary findings or presents an early prototype before continuing. This lets teams course-correct without micromanaging each step, preserving the autonomy advantages of extended agent runs while limiting the blast radius of a wrong early assumption.

The /effort command adjusts how much computational reasoning Claude applies to each step. Osmani recommends starting at /effort medium and tuning based on observed output quality. This replaces the common prompt pattern of instructing Claude to "think carefully" or "be thorough" — behaviors that Opus 5.5 applies based on its internal effort tier rather than requiring explicit instruction.

When to Use Subagents and When Not To

Claude Code can dispatch subagents — separate model instances — to handle portions of a task in parallel. Osmani's guidance on subagent sizing addresses a common miscalibration: using explicit parallelism instructions for tasks that are too small to benefit from the coordination overhead.

Spinning up a subagent requires context transfer, model orchestration calls, and output consolidation. For a targeted bug fix or a single-module change, that overhead exceeds any parallelism benefit. Osmani notes that Claude's own automatic dispatching is often sufficient for routine work and that teams should let it self-organize rather than issuing explicit parallel-subagent instructions for small tasks.

For genuinely large and independent workloads — full codebase audits, cross-module migrations, comprehensive test generation — explicit requests for parallel subagent execution make sense. The operative distinction is whether the subtasks are meaningfully independent: if they share state or require sequential dependencies, forcing parallelism creates coordination costs without corresponding throughput gains.

One specific application where subagents add clear value is code review. Osmani reports that within Anthropic's Claude Code team, most changes go through at least one Claude-assisted review pass before reaching a human reviewer. The /code-review command in Claude Code launches a fresh subagent that has not seen the current session context, providing a more independent evaluation of the diff. Alternatively, opening a new session with a requirements specification and asking for a focused review — emphasizing functional correctness over code style — produces a structurally similar result without requiring Team or Enterprise plan access.

Cloud Sessions and Projects: Managing Work That Runs Without You

Two recent Claude Code infrastructure additions address the challenge of running tasks beyond a single seated work session.

Cloud sessions, accessible via claude.ai/code, the Claude mobile application, or the claude --cloud terminal flag, run on Anthropic-managed virtual machines with a fresh clone of the connected GitHub repository. The practical consequence is that the session persists after closing a laptop, allowing longer tasks to run overnight or across a work break. Users can monitor session progress from a mobile device, answer questions the model raises mid-task, and review the resulting pull request without being physically present at their development machine. Tasks that require local-only resources — a local database, a device-specific tool, hardware-dependent testing — remain appropriate for local execution.

Because cloud sessions clone the repository fresh, any uncommitted local changes must be pushed to a remote branch before starting — an adjustment for teams that habitually work with local-only state.

Claude Code Projects, now in public beta for Pro and Max plan users on a waitlist basis since October 9, 2026 — expanded from an initial select-user beta that launched September 17 — provide a structured layer above individual sessions. A Project functions as a persistent context that spans multiple sessions: the user posts tasks or problems into a shared conversation, and Claude creates separate threads — usually executed as parallel cloud sessions — for each piece of work. Project-level instructions persist across threads, so teams can set once and apply across all tasks rather than re-specifying context for each new session. The Overview page consolidates task status, pull requests awaiting review, and questions waiting for user responses into a single dashboard.

Projects remain in beta and are not yet available on Team or Enterprise plans.

Auto Mode, Verification, and the Real Work Shift

Recent versions of Claude Code default to auto mode for interactive terminal sessions, with a classifier evaluating each of Claude's actions rather than prompting the user to approve individual steps. Osmani acknowledges that auto mode still has limitations: the classifier is not infallible, and the permission prompts that do surface require careful consideration rather than reflexive approval.

As more execution is delegated to Claude — longer sessions, parallel subagents, cloud-based overnight runs — the developer's primary responsibility shifts from writing instructions to verifying outcomes. When Claude reports a task complete, Osmani recommends requesting a structured output of the commands run and their results, or a screenshot of the final state, before accepting it. The verification step is not optional; it is the new primary job.

This is consistent with a broader pattern Osmani has addressed in related contexts: as AI-assisted coding scales up, the bottleneck is not generation speed but human ability to evaluate what was generated. A model that can autonomously write and commit code faster than a team can review it creates a verification problem more significant than the productivity gain. The prompt-debt cleanup, the acceptance-criteria workflow, the /goal-driven autonomous loop, and the code-review subagent are all, at bottom, tools for making the verification step faster and more reliable — not tools for eliminating it.

The Practical Implications for Teams Using Claude Code Today

The immediate action for any team with a mature CLAUDE.md file or accumulated agent instructions is to run /doctor prompt-audit and treat its output as a starting point for deliberate pruning. Teams that built their instruction files before September 2026 — before Opus 5.5 shipped — are most likely to be carrying significant prompt debt.

The broader implication is structural. Osmani's October 29 post is the clearest public statement yet that prompt engineering for frontier models is not a stable skill that accumulates compound value over time. It is a practice that requires periodic recalibration as model capabilities change — more like dependency management in a software project than like writing documentation that stays useful indefinitely. The /doctor prompt-audit command reflects that reality by making the recalibration automated rather than dependent on developer memory or discipline.

Whether the 80-percent figure applies uniformly across all codebases is an empirical question rather than a guarantee. Anthropic's internal deletion produced no measurable loss on its coding evaluations, but different teams work at different points in the complexity-and-specificity tradeoff. What the data does establish is that the default assumption should now be skepticism toward accumulated instructions, not deference to them.

The next milestone to watch is the expansion of Claude Code Projects to Team and Enterprise plans. When that happens, the structured parallel-session workflow Osmani describes will become accessible to the organizational settings where prompt debt is likely most severe and most costly.