Anthropic Removed 80% of Claude Code's System Prompt. You Should Prompt Less Too.

Anthropic removed over 80% of Claude Code’s system prompt for Claude Opus 5 and Claude Fable 5. No measurable loss on their coding evaluations.

Claude 5 generation models are smart enough that over-prompting actively hurts performance.

The Core Insight

With older models, the bottleneck was the model itself — you compensated for its limitations with detailed instructions, guardrails, and examples. With Claude 5, the bottleneck is you: your ability to clarify what you actually want.

Anthropic’s system prompt contained conflicting instructions like “leave documentation as appropriate” and “DO NOT add comments” in the same request. The model had to parse these contradictions before doing any useful work.

What Changed

Six patterns that were necessary for older models but are now myths for Claude 5.

graph LR
  subgraph old ["Old Playbook"]
      A1["Give Claude rules"] --> A2["Give Claude examples"]
      A2 --> A3["Put everything upfront"]
      A3 --> A4["Repeat yourself"]
      A4 --> A5["Manual memory"]
      A5 --> A6["Simple specs"]
  end
  subgraph new ["New Playbook"]
      B1["Let Claude use judgment"] --> B2["Design interfaces"]
      B2 --> B3["Progressive disclosure"]
      B3 --> B4["Simple descriptions"]
      B4 --> B5["Auto-memory"]
      B5 --> B6["Rich references"]
  end
  A1 -.->|"replaced by"| B1
  A2 -.->|"replaced by"| B2
  A3 -.->|"replaced by"| B3
  A4 -.->|"replaced by"| B4
  A5 -.->|"replaced by"| B5
  A6 -.->|"replaced by"| B6

Rules → Judgment

Old Claude Code said: “Never write multi-paragraph docstrings — one short line max. Don’t create planning documents unless the user asks.”

The rule also told Claude not to write comments when the user explicitly wanted them.

New Claude Code says: “Write code that reads like the surrounding code: match its comment density, naming, and idiom.”

Examples → Interfaces

Examples constrain the model to a specific exploration space. Instead, design expressive interfaces. A tool with a status parameter accepting pending, in_progress, and completed already tells Claude how to use it.

Everything Upfront → Progressive Disclosure

Old Claude Code loaded code review and verification instructions in the system prompt — always, even when irrelevant. Now these are skills Claude loads selectively.

Don’t create a central repository of every practice you might need. Create a tree of files that load at the right time.

Repeating → Saying It Once

Older models sometimes ignored content at the start of a long context window. Claude 5 doesn’t have this problem. Put instructions in the tool description, not the system prompt.

Manual Memory → Auto-Memory

The old advice was to use the # hotkey to save things to CLAUDE.md. Now Claude automatically saves memories relevant to your work.

Simple Specs → Rich References

Plan mode used markdown files. Now Claude can handle HTML artifacts, code in other languages, test suites as specs, and rubrics that encode taste.

Why More Prompting Hurts

Anthropic: “LLMs have an ‘attention budget’ that they draw on when parsing large volumes of context. Every new token introduced depletes this budget.” Chroma evaluated 18 LLMs and found that “model performance varies significantly as input length changes, even on simple tasks” — context rot.

ThoughtWorks Technology Radar Vol 34 flagged agent instruction bloat as a Caution: “Instructions become long and sometimes conflict with each other. Models tend to attend less to content buried in the middle of long contexts.”

Every redundant rule, every repeated example, every conflicting instruction costs you performance.

Finding Your Unknowns

The shift to prompting less changes how you work with Claude on any task. When you have fewer unknowns, you need less context. When you have more unknowns, you need to discover them — not compensate for them with verbose instructions.

The categories of unknowns:

graph TD
  A["Your Unknowns"] --> B["Known Knowns"]
  A --> C["Known Unknowns"]
  A --> D["Unknown Knowns"]
  A --> E["Unknown Unknowns"]
  B -->|"In your prompt"| F["What you tell Claude"]
  C -->|"Aware of gaps"| G["Ask Claude to research"]
  D -->|"Recognize when seen"| H["Brainstorm & prototype"]
  E -->|"Haven't considered"| I["Blind spot pass"]

• Known Knowns: What you tell the agent.
• Known Unknowns: What you know you haven’t figured out. Ask Claude to research.
• Unknown Knowns: What’s so obvious you’d never write it down. Brainstorm and prototype.
• Unknown Unknowns: What you haven’t considered. Do a blind spot pass.

The best agentic coders discover unknowns iteratively — before, during, and after implementation.

A Real Example

The launch video for Claude Fable was edited end-to-end using Claude Code. The editor had no video editing expertise:

1. Blind spot pass: “I don’t know anything about video editing. What do I not know?”
2. Prototyping: “Make me a test video with transcription to see if this works.”
3. Learning: “Teach me about color grading so I can make better requests.”
4. Implementation plan: “Here’s what I want. What decisions will I likely change?”
5. Post-implementation quiz: “Make sure I understand everything that happened.”

No 500-line prompt. Claude helped discover what to ask for, then delivered exactly that.

What This Means for Your Agents

If you’re building AI agents, the same principle applies. Audit your system prompt, skills, and CLAUDE.md files. Anthropic cut 80% of theirs — you likely can too. The claude doctor command in Claude Code helps rightsize your context.

The question isn’t “how do I give Claude more context?” It’s “how do I give Claude less?”

Related Reading

• Executable Skills for Agents Are Better Than Docs — documentation was built for humans; agents need executable code
• Full Agent Observability in Your Own Database — tracing every LLM call in LangChain DeepAgents
• Determinism as Infrastructure — why AI platforms need deterministic execution
• Spec-Driven vs Code-First vs Chat-to-Code — three philosophies for teaching AI about your business

Frequently Asked Questions

Why did Anthropic remove 80% of Claude Code’s system prompt? Claude 5 models had better judgment. The old instructions were overconstraining the model, causing conflicting signals and worse performance. Removing them with no measurable loss proved the model could handle decisions autonomously.

Why is more prompting harmful? Every token depletes an “attention budget.” Redundant instructions, repeated examples, and conflicting rules force the model to parse noise. Chroma found that “model performance varies significantly as input length changes, even on simple tasks” — context rot.

What is progressive context disclosure? Instead of loading all instructions upfront, give the agent a lightweight index. It selects what’s relevant and loads details only when needed.

Tags: context-engineering claude-5 prompt-engineering ai-agents anthropic claude-code less-prompting progressive-context-disclosure context-rot agent-instruction-bloat