Why Anthropic deleted 80% of Claude's system prompt and what this means for AI product builders. Learn the empirical approach to modern AI development.
Less Prompting = Better AI Results: The 80% Deletion Strategy
Quick Summary
- Anthropic deleted 80% of Claude's system prompt after releasing Opus 5—and performance improved
- Modern AI models are "living creatures," not static systems—they need re-evaluation with every new generation
- Don't predict what to delete; test empirically. Run tasks, observe where the model struggles, and only add instructions back when truly needed
- Today's models already possess significant untapped capabilities—the bottleneck is often the product constraints, not the model's ability
- The two essential skills for working with modern AI: (1) assign challenging tasks and (2) enable self-verification
Why Deleting Prompts Made Claude Smarter
When Anthropic released Opus 5, they took an unconventional approach: they removed 80% of Claude Code's system prompt. Counterintuitive as it sounds, the model performed better afterward.
The reason? Those deleted sentences were written to compensate for limitations in previous models. As Boris Cherny, creator of Claude Code, explained on stage at Y Combinator's Startup School 2026, a thick instruction manual doesn't mean the model is good—it often means the model had many shortcomings that needed manual correction.
Once the model evolved enough to handle those tasks naturally, the instructions became dead weight. Every conversation starts by reading those lines, yet they change nothing. Worse, they can force the model into outdated patterns even when it's capable of better approaches.
The Problem with Predicting What to Keep
After deletion, the instinct is to immediately replace what was removed. Most teams think: "This will definitely be necessary. That can't be missing." So they recreate almost identical prompts, essentially undoing the deletion.
This is the trap.
Instead, Cherny recommends an empirical approach:
- Delete boldly—remove the entire manual
- Use it first—run actual tasks with the new model, no predictions
- Observe failures—note where it consistently struggles
- Add back minimally—only restore instructions that address repeated problems
But there's a cost to every instruction: longer prompts reduce the model's capacity for the actual task. Ten unused rules can obscure one truly essential line. Consider whether that instruction will be read every single time in the future, not just once.
Task Design is More Important Than Prompt Quality
Modern AI development differs fundamentally from traditional software engineering. You can't design a perfect system upfront and execute it. Instead, treat models like living organisms: each new generation has a different personality.
The two most critical skills are:
1. Assigning the Right Challenge
Don't be overly specific. Detailed step-by-step instructions actually hinder modern models. Instead, state the task at a high level, define the boundaries, and let the model determine the approach.
2. Enabling Self-Verification
This is where most people fail. Without a verification mechanism, the model keeps running without feedback—stuck, unaware it's gone wrong. When verification exists, the model detects errors, corrects them, and tries again autonomously.
These two are intertwined: harder tasks require stronger verification. Easy tasks surface errors quickly; massive tasks may hide discrepancies until much later.
Product Overhang: Untapped Capability in Today's Models
There's a gap between what a model can do and what the product allows it to do. Cherny calls this "product overhang"—surplus capability that no product currently captures. When the product's constraints suppress the model's ability, it's "hobbling."
Many tasks we assume are impossible haven't been properly attempted. Or we tried, but established procedures blocked them midway.
A striking example: when Claude Code ran on Opus 5, existing coding products offered single-line autocomplete or chat-based code review. None elicited the model's true capability—writing entire functions or files at once. By stripping away all scaffolding and giving the model the simplest possible framework, Claude Code unlocked what was already possible.
How Self-Verification Enabled an 11-Day Codebase Rewrite
The Bun team (creators of a JavaScript runtime written in Zig) needed to rewrite their codebase from Zig to Rust. They asked Claude to handle it with one prompt, using dynamic workflows—a system that orchestrates dozens, hundreds, or thousands of agents working in parallel.
The rewrite ran for 11 days straight and completed successfully. In the past, this would have taken years of human engineering.
Why did it work? The Bun codebase had comprehensive tests. The model could take a screenshot, run tests, observe results, and adjust. It had built-in verification every step.
Anthropic Now Uses Agents for Daily Maintenance
Anthropic deployed routines—single-sentence prompts that run every day across their entire codebase:
- Dead code cleanup: Identifies and proposes deletion of unused code
- Experiment shipping: Removes code for experiments that reached 100% deployment
- Test coverage: Writes tests for undertested areas
- Test cleanup: Deletes redundant tests added by older models
- Abstraction police: Finds duplicated abstractions across the codebase and unifies them
Hundreds of agents—sometimes thousands—run daily, doing the work of dozens or hundreds of human engineers. None of these routines were explicitly instructed to use static and dynamic analysis, yet the model independently chose these methods.
"Coding is Solved"—But With Caveats
Cherny stated that coding is solved for the kind of work he does. The caveat: models still struggle with very deep systems code, distributed systems, and pixel-perfect screen alignment. Opus 5 made major strides in vision and computer interaction, but perfection hasn't been reached for all code types.
When he asked the audience how many wrote 100% of their code using agents, few hands went up. More than 50%? Slightly more. This suggests coding is becoming solved incrementally across different domains, but not universally—yet.
What Beginners Should Actually Learn
At the talk's end, Cherny was asked what new programmers should learn in an era where AI writes code. His answer wasn't about curriculum—it was personal:
He first learned to code on a TI-83 calculator in middle school to cheat on math tests. He wrote a guide on the internet (still there) teaching calculator programming in BASIC. When math got harder, he moved to assembly to build better solvers. Eventually, programming became about solving real problems.
His advice: Learn to apply it. Study not just computer science theory, but how to build startups, products, design sense, business acumen, data science, and how to talk to users. Those who excel at shedding preconceptions—forgetting what past models could or couldn't do, ignoring theory—adapt fastest to today's AI.
Conclusion
The shift in AI development is radical: instructions are no longer permanent assets but temporary tools that must be re-evaluated with each model. Success belongs to those who empirically test rather than predict, who challenge models appropriately while enabling verification, and who recognize untapped capability in today's systems.
The future isn't about prompt engineering. It's about building environments where AI can operate autonomously, and about adopting an empirical mindset: try it, observe where it struggles, and adjust.