Anthropic Cut Claude Code's System Prompt by 80%—and It's a Philosophy, Not an Optimization

At the 2026 AI Engineer World's Fair, Simon Willison sat down with Anthropic's Cat Wu (Product) and Thariq Shihipar (Engineering) from the Claude Code team for a fireside chat. The hour-long conversation was dense with counterintuitive conclusions—from Claude Tag now landing 65% of the team's PRs to “rewrites are now good.” But one detail, delivered almost offhandedly by Thariq, kept echoing in my head:

Claude Code's system prompt has been reduced by 80% for frontier models like Fable and Opus 4.8.

Cutting four-fifths of a product's core instructions isn't an optimization. It's a philosophical pivot.

What Got Removed

Thariq was candid about what was cut. Two categories:

First, few-shot examples. His exact words: “Removing examples was very helpful because Fable is more creative than the examples we gave it.”

Let that sink in. For years, the prevailing wisdom in prompt engineering has been that a well-crafted example is worth more than a hundred lines of instruction. Fable flips this logic on its head: your carefully curated examples become a ceiling, not a floor. The model is smarter than your examples—why make it imitate a worse version of itself?

Second, hard prohibitions. Thariq explained that strong “never do X” constraints often conflict with legitimate user requests that genuinely require X, confusing the model. “We try to reduce hard constraints, add more context, and reduce overall instructions.”

Cat Wu offered a concrete illustration: the old instruction required Claude Code to “always verify” frontend changes. The new version says “most of the time.” Because if you're just changing a string literal and the user says “quick fix and update the tests,” maybe you don't need to fire up a browser to verify.

“More Context, Fewer Prohibitions”

These six words capture Anthropic's emerging prompt philosophy.

Software development has spent decades migrating from imperative programming (telling the computer every step) to declarative programming (describing the result you want). What Anthropic is doing with prompts is fundamentally the same shift—moving from “tell the model how to think at every step” to “describe the context and boundaries clearly, then trust the model's judgment.”

This trust isn't blind. Thariq emphasized that the reduction is model-dependent—older models still receive the full system prompt. The privilege of cutting instructions only exists when you have genuine confidence in the model's capabilities. Slimming down your prompt isn't a universal best practice; it's a capability unlock.

If you're using a weaker model, you still need those examples and guardrails. If you're using Fable, every extra line of instruction might be another layer of unnecessary constraint.

Where This Philosophy Comes From

Anthropic's approach to prompt design mirrors their approach to product development—and it's worth understanding both.

Cat Wu outlined Claude Code's product decision funnel: ship internally to all Anthropic employees first, collect early feedback (“the more brutal the better”), and set explicit retention thresholds. If a feature doesn't hit the bar, it doesn't ship. This turns what could be a subjective “I think this is good” into a data-driven question: users vote with their feet, and retention tells the truth.

This is the same thinking behind the prompt reduction. Don't pre-emptively constrain behavior with rigid rules. Give enough context (real usage data), trust the system (retention metrics) to surface what's right.

Simon Willison's “Prompt-Writing Prompt” Pattern

Simon himself mentioned a prompt engineering framework he practices: using a capable agent to generate customized prompts for sub-agents. This pattern already embodies Anthropic's philosophy:

If you trust the primary agent's judgment, don't shackle it with a one-size-fits-all system prompt. Let it generate the right “sub-prompt” for each context. This is “more context, fewer prohibitions” in practice.

From Prompts to Products: The Same Philosophy at Scale

Zoom out, and you'll see this “trust the model's judgment” philosophy spreading across Anthropic's product line:

• Auto mode is fundamentally “I trust Claude to decide when to call which tool”—no permission prompts, no human gatekeeping at every step.
• Claude Tag drops an AI agent directly into team Slack channels, autonomously monitoring bug reports and opening PRs—no manual trigger required.
• Automated code review is progressively taking over “outer layer” changes—moving from “human reviews everything” to “trust automated review, with humans at critical checkpoints.”

These decisions share the same underlying logic: once model capability crosses a threshold, “control” stops being the optimal strategy. “Trust + feedback loop” becomes the new playbook.

What This Means for Practitioners

The biggest takeaway from this fireside chat wasn't a technical detail—it was a mindset shift.

When asked about job displacement anxiety, Thariq's advice was simple: “Be more ambitious.” He described using Fable to edit his product's launch video—auto-transcription, dynamic cropping, speaker tracking, generated animations. A year ago, this would have required a professional video team. Now one person does it in hours.

The 80% prompt reduction is the same story. When your tool is smart enough, your most important job isn't writing more instructions. It's raising your standards.

Cut the babysitting examples. Cut the hard prohibitions. Trust it to understand context. Then go do what one person couldn't do before.