What is context engineering and why does it matter?
When you send a message to Claude, your prompt represents only a tiny fraction of what the model actually receives. The bulk of the context is assembled from several sources: the system prompt, CLAUDE.md files, Skills, persistent memory, and other elements configured upstream. The entirety of this process is called context engineering.
Unlike a classic prompt, which is written for a specific request, context is used across many different requests. It must therefore be general enough to remain relevant in varied situations, while still effectively guiding the model. This is a delicate balancing act, and that balance has changed considerably with the arrival of Claude 5 models.
The team behind Claude Code recently made a surprising discovery: by working with models like Claude Opus 5 and Claude Fable 5, it was possible to remove more than 80% of Claude Code’s system prompt with no measurable loss on code evaluations. This figure illustrates just how much the new context engineering practices differ from those that were in place only a few months ago.
Freeing Claude from excessive constraints
One of the first lessons drawn from this evolution is that older models were over-constrained. System prompts accumulated sometimes contradictory rules, redundant examples, and very rigid instructions designed to avoid the worst possible scenarios.
For example, an instruction like “Never write multi-line comments” could be completely unsuitable for certain complex projects where detailed documentation is essential. These guardrails were necessary for older models, but they become counterproductive with new generations, which possess better contextual judgment.
The shift from a logic of rigid rules to a logic of trusting the model’s judgment is at the heart of this evolution. Rather than telling Claude exactly what to do in every situation, we now give it general principles and let it adapt its behavior to the real context.
Old practices that have become obsolete
Here is an overview of the context engineering myths that have been called into question with Claude 5 models.
Giving strict rules versus trusting judgment
Previously, it was necessary to formulate very precise rules to avoid undesirable behaviors. Today, an instruction like “Write code that looks like the surrounding code: respect its comment density, naming conventions, and idioms” is sufficient. Claude adapts its behavior according to context, without needing to anticipate everything in advance.
Giving examples versus designing expressive interfaces
The number one rule for tool usage was to provide concrete examples. With new models, examples tend to constrain the model’s exploration to too narrow a space. It is better to design tools with expressive parameters. For example, a task management tool whose status is defined by a clear enumeration (pending, in_progress, completed) naturally guides Claude on how to use it, without needing detailed examples.
Putting everything upfront versus progressive disclosure
Old system prompts included all potentially useful information from the start, even when it was not always necessary. Progressive disclosure means loading the right context at the right time. Specific instructions, such as those related to code verification, can be moved into dedicated Skills that Claude calls only when needed.
Repeating yourself versus concise tool descriptions
Older models sometimes needed instructions repeated in different places throughout the context in order to remember them correctly. With Claude 5, it is enough to place instructions in the description of the relevant tool. Repetitions in the system prompt are not only unnecessary, they can even harm clarity.
Manual memory versus automatic memory
It was previously recommended to encourage users to manually save information in CLAUDE.md files. Now, Claude automatically saves elements that are relevant to the project and to the user, reducing the cognitive load required for memory management.
Simple specifications versus rich references
Simple markdown files were the standard for storing plans and specifications. New models can leverage far richer references: HTML artifacts, detailed test suites, functions from other codebases, or evaluation rubrics that allow Claude to understand your stylistic or architectural preferences in a given domain.
How to assemble your context today
By applying these new principles, here is how to effectively structure your context for Claude 5.
The system prompt
The system prompt is closely tied to the product context. It tells Claude what environment it is operating in and what its general role is. If you are using Claude Code as-is, you will probably never need to modify it. On the other hand, if you are building your own agent, this is where you should concentrate the bulk of your design effort.
The CLAUDE.md file
Keep your CLAUDE.md light and concise. Briefly describe the purpose of the repository, then focus the information on the specific quirks and pitfalls of your codebase. Avoid repeating things that Claude can deduce directly by exploring your file tree.
- Mention non-obvious conventions (for example, all types in a single monolithic file).
- Reference Skills for detailed instructions rather than integrating everything directly.
- Use progressive disclosure: create a file tree that is loaded at the right moment.
Skills
Skills are lightweight guides that allow Claude to find the information it needs at the right moment. Avoid over-constraining them, except in critical areas. For long Skills, split them into multiple files and apply progressive disclosure. The best Skills encode opinions, knowledge, or practices specific to your team or product.
References
You can mention files directly in your exchanges with Claude to include them as references. Prefer references in code form rather than textual descriptions or screenshots: an HTML mockup will generally produce better results than a written description of the same design, because Claude understands code with great precision.
Simplifying: the key approach for new models
If you have built complex system prompts, Skills, or CLAUDE.md files with older models, it is time to revisit them. Simplification is not a loss: it is an opportunity to let the native capabilities of Claude 5 models express themselves fully.
The claude doctor tool (accessible via the /doctor command in Claude Code) was designed to help you automatically analyze and simplify your context files. It identifies redundant instructions, unnecessary constraints, and sections that can be moved into dedicated Skills.
In summary, context engineering for Claude 5 rests on three main principles: trust the model’s judgment rather than trying to anticipate everything, load context progressively rather than putting everything upfront, and design expressive interfaces rather than multiplying examples. These principles may seem counterintuitive if you are accustomed to older models, but they reflect a profound evolution in the capabilities of next-generation LLMs.
Adopting these new practices not only improves the quality of your agents’ results, but also reduces the complexity of maintaining them over the long term. Fewer rules, fewer repetitions, and a model that genuinely understands what you want to build.
