You can delete 80% of the system prompt you wrote for Claude 3. It will perform better.

This is not a hot take. This is what Anthropic did internally for Claude Code when they rolled out Opus 5 and Fable 5. They removed almost all the rules, guardrails, examples and repeated instructions. Evaluation scores did not drop. They went up.

Every assumption you have about prompting agents is wrong for this generation of models. This article walks through what changed, how to build skills correctly now, and what actually works when you are not building demo toys.

The end of rule based prompting

For three years the standard advice was: be explicit. Write every rule. Repeat important instructions at the end. Give three examples. Add guardrails for every bad outcome you can imagine.

That was correct. For models released before 2026.

New models do not need rules. They need boundaries.

When Anthropic audited Claude Code's system prompt they found lines like:

Never write multi-paragraph docstrings. One line maximum. Do not create planning files.

This was not bad engineering. This was required for Claude 3 Opus. Without this line it would dump 12 line docstrings on every function. With this line, it would refuse to write docstrings even when the user explicitly asked for them.

For Claude 5 this entire block was replaced with one line:

Write code that reads like the surrounding code.

That is it. No exceptions. No edge cases. No rules. The model will match idiom, comment density, naming convention and style correctly on its own. It will also correctly override this behaviour when a user asks for something different.

Overconstraining is now the single largest mistake people make building agents. You are not making the model more reliable. You are making it dumber. It will spend more reasoning cycles resolving conflicting instructions from you, the skill, the system prompt and the user than it will spend solving the actual problem.

Old vs new context engineering rules

This is the complete shift. Every row here is a reversal of accepted best practice from 12 months ago.

Then (Claude 3 and older)	Now (Claude 5 generation)
Write explicit rules for every edge case	Define desired outcome, let model use judgement
Include 2-3 examples for every tool	Do not include examples. Design good tool interfaces.
Dump all context up front in the system prompt	Use progressive disclosure. Load context only when needed.
Repeat important instructions 2-3 times	State everything exactly once, in the correct place.
Store permanent instructions in CLAUDE.md	Use built in auto memory.
Write plain text specs and plans	Reference code, tests, artifacts and rubrics.

None of these are opinions. These are the changes Anthropic shipped to production after running this against their full internal evaluation suite.

What is actually inside a context window

Before we go further it is critical you stop thinking of the context window as storage. It is not memory. It is execution surface.

This is the single most common mental model error. The context window is the scratchpad the model uses for this one single inference run. Nothing inside it survives after the token is generated.

There is no magic. There is no remembering. When you add something to the context window you are not teaching the model something. You are placing it on the desk in front of the intern while they work on this one task.

When the task is done, everything on that desk gets thrown away.

This explains every weird behaviour you have ever seen:

• Models forget things in the middle of long context
• Instructions at the start and end work better
• Adding more context often makes outputs worse
• Models will happily contradict something they wrote 10 messages earlier

Bigger context windows do not fix this. They just give you a bigger desk. You can pile more paper on it. The intern will still ignore most of what is there.

MCP is not a tool protocol. It is a context protocol.

Everyone explains the Model Context Protocol as a standard for connecting tools. That is the marketing line. That is not what makes it important.

MCP solves progressive disclosure.

Before MCP, every tool definition had to be listed in full in the system prompt. 20 tools meant 3000 tokens permanently burned in every single inference, even if the user never called any of them.

MCP changes this. The agent can search for tools. It can load a tool definition only when it decides it needs that tool. It can discard it afterwards.

This is why you can now have 100 tools installed in Claude Code and not notice any performance degradation. 99 of them are not in the context window at all until the moment the agent decides to use one.

This is the single largest architectural improvement to agents in the last two years. Almost no one talks about it. Everyone is still arguing about prompt formatting.

Anatomy of a good skill

If MCP is the hands, a skill is the muscle memory. A skill is not code. It is context that teaches the agent how to behave when using those tools.

Good skills do not contain rules. They contain norms.

Look at the NB2Lite image editing skill. It is one of the best public examples of a correctly written modern skill. It does not say:

You are an expert image generator. Always be helpful. Do not generate harmful content.

It says exactly four things:

1. Call get_help first if anything is broken
2. Edit prompts should only describe the change. Never restate the whole scene.
3. Always chain the latest interaction ID. Never use an old one.
4. Use low thinking level for drafts. Only use high for final outputs.

That is the entire skill. No examples. No fluff. No guardrails. 117 words. It works perfectly.

Bad skills are 2000 words long. They start with a 5 paragraph persona. They list every edge case the author could imagine. They repeat instructions three times. They will perform worse than no skill at all on modern models.

Progressive disclosure in practice

Progressive disclosure is not just for tools. You should apply this to every part of your agent setup.

Stop putting your entire engineering handbook in CLAUDE.md. Stop dumping 50 pages of process into the system prompt.

Instead:

• CLAUDE.md should be less than 20 lines. It should only contain things that are true 100% of the time, and cannot be discovered by reading the codebase.
• All process, conventions and verification steps go into separate skill files. The agent will load them only when it needs to perform that action.
• Never write "always run linter before committing". Write a linter skill. The agent will find it when it is about to commit.
• Specs should be test suites. Not markdown documents. If you want the agent to build something correctly, write the test first. The model will read the test and produce code that passes it. It will do this far better than it will ever follow a written description.

The claude doctor command

Anthropic built this entire set of rules into a single command you can run right now.

Type /doctor in any Claude Code session.

It will scan your system prompt, your CLAUDE.md and all installed skills. It will tell you exactly what you can delete. It will tell you where you are overconstraining. It will tell you what should be moved into a separate skill.

In most user repos it recommends deleting between 60% and 90% of the existing context. Almost no one pushes back after they try it.

You should run this before you spend another hour writing prompt text.

Why everyone got this wrong

This shift is so large most people have not caught up yet. All the blog posts, all the courses, all the youtube tutorials you watched were written for older models. They are now actively harmful.

This is not the first time this has happened. It will not be the last. Every time model capability jumps by this much, every single best practice reverses.

The mistake almost everyone makes is that they build for the weaknesses of old models. They add workarounds, guardrails and hacks to compensate for things the model could not do. Then the model gets fixed. The workarounds stay. They become drag.

Right now you are carrying around hundreds of lines of prompt text that existed only to fix bugs in Claude 3. They are now making Claude 5 worse.

Delete them.

Practical steps for this week

1. Go to the system prompt you use for your internal agent. Delete 50% of it right now. Run your evaluations. They will almost certainly go up. If they don't, delete another 20%.
2. Remove all examples from all tool definitions.
3. Move every instruction that is not always applicable into a separate skill.
4. Run /doctor in Claude Code in your main repo. Do what it says.
5. Build one skill that does one thing well. Do not write more than 200 words in the SKILL.md.

This is not theory. This is what the people who built the model are doing internally. You do not have to guess what works. They already told you.

---

References

1. The new rules of context engineering for Claude 5 generation models | Anthropic https://claude.com/blog/the-new-rules-of-context-engineering-for-claude-5-generation-models
2. Teaching Claude Code to Paint | dev.to https://dev.to/gde/teaching-claude-code-to-paint-a-stateful-image-editing-skill-built-on-geminis-interactions-api-17g
3. What is a context window, actually? | dev.to https://dev.to/ale3oula/what-is-a-context-window-actually-13l
4. Model Context Protocol specification https://modelcontextprotocol.io