You’ve been doing it wrong. And honestly, it’s not your fault. Every tutorial, every expert, every Medium article told you to pile on examples, rules, and constraints. The more detailed the prompt, the better the output. Right?
Wrong. That’s the old playbook. The new one? Delete 80% of your system prompt and watch your AI actually get smarter.
I’m not talking about some theory. Claude Code — the AI coding agent used by thousands of developers — just did exactly that. Thariq Shihipar, the person who runs Claude Code, published a post titled “We removed over 80% of Claude Code’s system prompt for more advanced models.” And the result? No measurable loss on coding evaluations. None. Zero.
Let that sink in. They cut four-fifths of the instructions they were giving their own AI, and it didn’t get dumber. It got better. More flexible. Less brittle.
Here’s the real story behind why less is suddenly more — and how you can apply it to your own work without becoming a prompt engineer.
The Paradox of Control
We’ve been told that AI is a dumb machine that needs hand-holding. Give it step-by-step rules. Spell out every edge case. Threaten it with “NEVER do X.” But here’s the uncomfortable truth: every rule you add is a bet that the model can’t figure it out on its own. And with the latest generation of models — Claude Opus 5, Claude Fable 5 — that bet is losing.
The Claude Code team found that their system prompts were full of contradictory instructions. “Write documentation where appropriate” and “DO NOT add comments” were lurking in the same prompt. The AI had to waste mental energy (yes, attention budget is real) untangling its own orders before it could do useful work.
“We were overconstraining Claude Code,” says Shihipar. “These constraints were once needed to avoid worst case scenarios. But we found we can delete many of them and let the model use surrounding context and judgement instead.”
That’s a hard pill to swallow if you’ve built your career on crafting the perfect 10-page prompt. But the evidence is clear: the best prompt is the one that gets out of the way.
What Actually Changed
Here’s a before-and-after that will make you question everything you’ve learned about prompting:
Old rule: “Default to writing no comments. Never write multi-paragraph docstrings.”
New rule: “Write code that reads like the surrounding code: match its comment density, naming, and idiom.”
That’s it. No more dogma. No more absolute commands. The model is trusted to look at the context and decide.
Old rule: Give Claude examples of how to use every tool.
New rule: Design the tool interface well enough that examples aren’t needed. Let the model explore.
Old rule: Dump everything into one giant CLAUDE.md file.
New rule: Use a tree of files that load only when needed. Progressive disclosure.
This isn’t laziness — it’s the opposite. It’s realizing that the model’s judgment is now a resource you can lean on, not a liability you have to hedge against.
Why Your Prompts Are Making Your AI Dumber
There’s a concept called “attention budget.” Every token you add to the context window costs the model a little bit of its ability to focus. Long, repetitive instructions don’t just waste space — they actively degrade performance by diluting the model’s attention across conflicting signals.
Think of it like this: if you give someone a map with 50 extra landmarks that don’t matter, they’ll take longer to find the destination. If you give them a crisp, minimal map with just the key turns, they’ll get there faster — and probably discover a better route along the way.
Your AI is not a toddler. It’s a capable adult with good instincts. Start treating it like one.
What does this mean for you? Stop writing prompts that read like a legal contract. Stop repeating yourself. Stop adding examples for things the model can infer. Instead, focus on what the model can’t know: the unique gotchas of your codebase, the specific taste of your team, the weird edge cases that only you’ve encountered.
The New Rules of Context Engineering
Based on what Claude Code learned, here’s a shortlist of principles you can apply today:
- System prompt: Keep it short. It should only tell the model what product it’s in and what its core job is. Everything else goes into lighter-weight files.
- CLAUDE.md: Don’t make it a dump. Use most of your tokens for “gotchas” — things that are weird about your codebase. Skip the obvious stuff the model can see by looking at the files.
- Skills: Think of them as light signposts. Only encode opinions and practices that are unique to your team. Use progressive disclosure — split long skills into multiple files.
- References: Use code, not prose. A detailed test suite or a HTML mockup is a better spec than a paragraph of text. The model understands code better than your writing.
If you’re building agents, don’t fall into the trap of “more is better.” The team built a tool called claude doctor that automatically helps you rightsize your prompts. They had to; they realized their own system prompts were bloated with myths.
The Twist: Your Old Habits Are Holding You Back
Here’s the uncomfortable part. The reason you’ve been writing long prompts isn’t because it works — it’s because you’ve been trained to mistrust AI. Every time a model went off the rails, you added more rules. Every time it failed to follow instructions, you added more examples. You built a fortress of constraints, and now the fortress is crushing the life out of your output.
The biggest unlock for AI in 2026 isn’t a better model. It’s learning to stop over-engineering the context. The best prompt engineers are not the ones who write the most — they’re the ones who know what to delete.
So go ahead. Open your CLAUDE.md. Open your system prompt. And ask yourself: what would happen if I deleted half of this? What if I trusted the model to figure out the rest?
You might be surprised. The Claude Code team was. And they had the data to prove it.
FAQ
Q: Does this mean I should never write detailed prompts?
A: Not at all. Detailed prompts are still useful for rare edge cases or specific compliance requirements. But for general use, especially with the latest models, you should favor brevity and trust the model's judgment. The key is knowing when to be specific and when to step back.
Q: What if my model keeps making mistakes after I remove the constraints?
A: That's a sign that either your model isn't advanced enough to handle that freedom, or you haven't given it enough context about the 'gotchas' in your codebase. The solution isn't to add back the old rules — it's to provide better reference material (like test suites or concrete examples) and let the model learn from those.
Q: Isn't this just Anthropic marketing to sell their new models?
A: The principle is model-agnostic. As models improve, the optimal prompt strategy shifts from 'command and control' to 'guidance and trust.' It's a general trend, not a vendor-specific trick. The same logic applies to GPT-5, Gemini, or any other advanced model. Test it on your own stack — you'll likely see the same pattern.