Claude 5: The New Rules of Context Engineering

A New Design Theory for an Era Where More Rules Make AI Weaker

On July 25, 2026, Thariq Shihipar of the Claude Code team published the "New Rules of Context Engineering for Claude 5 Models."

https://x.com/trq212/status/2080710971228918066?s=20

The most shocking revelation is this:

Anthropic reduced the system prompt for Claude Code by over 80% for Claude Opus 5 and Claude Fable 5. Despite this, they reported no measurable performance degradation in coding evaluations.

Until recently, the way to improve AI accuracy was to add more rules, write detailed procedures, list prohibitions, and provide massive amounts of success stories.

However, in the Claude 5 generation, that common sense is starting to flip.

Adding too many rules doesn't make the AI smarter; it actually makes it weaker.

What Thariq, a member of the Claude Code development team, demonstrated this time isn't just a prompt trick. It's a shift in the very "information design philosophy" used to drive AI agents.

There are three main takeaways from this article:

First, what will be important going forward is not the ability to write long prompts, but the ability to design "what, when, and at what level of hierarchy" to show information to the AI.

Second, CLAUDE.md and Skills are not warehouses to stuff knowledge into. They are navigation systems for Claude to retrieve the necessary information at the necessary moment.

Third, in the era of Claude 5 context engineering, you shouldn't write rules to prevent the AI from making judgments; you need to create an environment where the AI can judge correctly.

This isn't just about Claude Code.

It applies directly to the design of all AI agents: article production, website creation, app development, video editing, research, internal AI, customer support, and sales support.

What is Context Engineering in the First Place?

Many people think only the messages sent to the AI are "prompts."

For example, suppose you ask Claude Code the following:

Please fix this login screen to have a more high-end design.

However, the information Claude actually receives is not just this one sentence.

Claude Code's system prompt, the project's CLAUDE.md, the user's global CLAUDE.md, Skill names and descriptions, the body of the called Skill, MCP tool definitions, past conversations, loaded files, command execution results, Auto-memory, the current working directory, referenced designs, and test results are all assembled into one massive context.

In Claude Code, even before the user types the first message, CLAUDE.md, Auto-memory, MCP tool names, and Skill descriptions are already in the context. As work begins, loaded files and tool results are added, and the context grows as the conversation gets longer.

In other words, a prompt is just the "current request."

Context is the entire work environment that determines how Claude interprets that request, what it prioritizes, which tools it uses, how far it executes, and what it considers a correct answer.

I think it's easy to understand if you think of it this way:

The prompt is the order. The context is the company itself.

If you ask a talented employee to "create this document," but the internal rules, customer info, past documents, available tools, quality standards, and approval authorities are a mess, they won't be able to do a good job.

AI is the same.

Even if you keep polishing the prompt, if the surrounding context is contradictory, outdated, bloated, and contaminated with irrelevant information, performance will not improve.

The Misconception That "More Information Makes It Smarter"

If the context window becomes 1 million tokens, you can put in a lot of information.

Consequently, many people think:

"If it fits, I should just put everything in."

However, the context window is not a warehouse.

It is the AI's working memory and attention resource.

Anthropic also explains that performance does not automatically increase as the context volume increases; rather, "context rot" can occur, where accuracy and recall performance drop as the amount of information grows. For agents that run for a long time, it is necessary to use compaction, structured notes, and multi-agents to suppress context contamination.

For example, suppose the following command is written in CLAUDE.md:

Do not write comments in the code.

In another Skill, it says:

Always add detailed comments for complex processing.

Furthermore, the user requests:

Please include plenty of comments for beginners.

Claude doesn't just have to write code. It has to consider the priority of these three commands, their scope of application, the current user intent, and the conventions of the codebase.

A new model will likely be able to make a reasonable judgment eventually. However, it will consume part of the reasoning power that should have been used for code design on "traffic control between commands."

This is the problem with old context design.

Friction between information makes the AI weaker than the amount of information itself.

I call this Context Debt.

Just as technical debt accumulates in code, debt accumulates in prompts, CLAUDE.md, Skills, and Memory.

Rules added to prevent past failures remain forever.

Instructions that became unnecessary as the model improved are not deleted.

Different people add similar commands using different expressions.

Old APIs, old configurations, and old workflows remain.

As a result, even though the AI has become the latest model, only the surrounding context remains bloated as it was in the past.

The higher the model performance, the more the old training wheels become a hindrance.

Why Could 80% of Rules Be Deleted in Claude 5?

The big change in the Claude 5 generation is not just the amount of knowledge.

Its ability to interpret ambiguous situations, continue long-term work, integrate user intent with the surrounding environment, manage sub-agents, and verify its own work has improved.

Anthropic explains that for Claude Fable 5, long-term autonomy, first-time correct rates for complex problems, next-action judgment in ambiguous situations, code review, and delegation to sub-agents have improved since Claude Opus 4.8. Furthermore, because instruction-following performance has increased, it has become easier to control behavior with short policies without having to list every individual action.

Previous models needed detailed guardrails to avoid the worst failures.

"Don't write comments."

"Don't create documents on your own."

"Don't do unnecessary refactoring."

"Don't add features the user didn't ask for."

"Always follow this order."

"When using this tool, call it exactly like this example."

At the time, these rules had practical value.

However, new models can judge more accurately than before whether "comments are necessary in this situation" or "refactoring should be included in this change" based on the surrounding code, user intent, and the nature of the project.

So Anthropic deleted detailed prohibitive commands and replaced them with higher-level policies.

For example, where they used to write many lines of rules about comments, they now change the thinking to:

Write in the same way as the surrounding code. Match comment volume, naming, and idioms to existing code.

This isn't about getting rid of rules.

It's about giving judgment criteria and leaving the judgment itself to the model.

New Rule 1

From "Giving Claude Rules" to "Giving Claude Judgment Criteria"

In old context engineering, specifying the AI's actions in detail was considered virtuous.

In new context engineering, you reduce rules full of exceptions and show the direction of judgment.

Bad examples include:

• Always keep variable names short
• Do not write comments
• Keep functions under 30 lines
• Do not create new files
• Do not add external libraries
• Refactoring is prohibited
• Always write type definitions in types.ts

Some of these may be right, and some may be wrong depending on the case.

To follow the "functions under 30 lines" rule, an even harder-to-read split might occur.

To avoid creating new files, existing files might become bloated.

To avoid adding libraries, incomplete custom implementations might be born.

A better way to write is as follows:

Match the structure, naming, comment density, and abstraction level of existing code. Keep the scope of changes to the minimum necessary to achieve the request. Only introduce new dependencies or abstractions if they clearly make the implementation simpler than the existing one.

Here, there are judgment principles common to all situations.

What a new model needs is not to be taught the correct answer one by one. It's to be told what to consider a good state, what to prioritize, and what kind of trade-offs to choose.

However, there is something to be careful about here.

"Leaving it to judgment" does not mean "you don't have to specify anything."

Clear boundaries are necessary for actions with high irreversibility or impact, such as deletion, sending, publishing, billing, deployment, and the use of personal information.

What should be left to judgment are areas that are highly context-dependent and reversible, such as implementation methods, expression methods, research methods, and code structure.

Conversely, security, laws, confidential information, money, external publishing, and destructive operations should continue to be explicitly controlled.

In short, the new principle is this:

Leave reversible execution to judgment, and place boundaries on irreversible execution.

New Rule 2

From "Giving Massive Examples" to "Designing Good Interfaces"

In previous AI agents, showing multiple examples of tool calls was effective for making the AI use tools correctly.

However, examples have side effects.

While Claude learns how to use them from examples, it is also pulled toward the search range shown by those examples.

Even if another combination, order, or parameter is more appropriate, it becomes easier to choose a method similar to past examples.

That's where tool interface design becomes important.

For example, suppose a Todo tool has the following states:

pending

in_progress

completed

Furthermore, if it is defined that "only one item can be in_progress at a time," Claude can understand the tool's state transitions without being given long usage examples.

Good tools have the following properties:

• The role is clear from the tool name.
• The scope covered by one tool is clear.
• Parameter names are not ambiguous.
• Choices are defined as enums.
• Return values for success and failure are known.
• Safe defaults are set.
• The return value contains information necessary for the next judgment.

Anthropic also explains that tools for agents shouldn't just wrap human APIs as they are. Increasing the number of tools isn't always better; namespace, returned context, token efficiency, descriptions, and evaluation design are important. Since tools stand out in the context, they must be designed around the primary actions the model should actually take.

However, it is also a mistake to understand that "examples are no longer needed."

In Claude's official prompt guide, a small number of high-quality examples are still considered effective as a means of stabilizing output format, style, and structure. In the official Skills guide, it is explained that input/output examples are effective in areas where quality depends on specific examples, such as commit messages.

To summarize:

Do not overuse examples to teach how to use tools. Make the tool interface itself easy to understand.

On the other hand, examples are worth using in areas where it's hard to explain the "correct answer" in words alone, such as tone of voice, design preferences, and special output formats.

In other words, you don't delete examples. You limit the job of the examples.

New Rule 3

From "Making It Read Everything First" to "Disclosing Only When Necessary"

Previously, the common design was to write everything in CLAUDE.md for fear that Claude wouldn't find the necessary information.

• Code review methods.
• Test methods.
• Deployment methods.
• Writing rules.
• Design rules.
• API specifications.
• Directory structure.
• Library list.
• Known bugs.

This was because people thought that if they put everything at the beginning, Claude wouldn't miss it.

However, this is like making every employee in a company read all the internal manuals every morning before starting work.

Even if today's job is accounting, you make them read the sales manual, recruitment manual, video editing manual, and troubleshooting manual.

The information exists, but the proportion of information necessary for the current job decreases.

The core concept of the Claude 5 era is Progressive Disclosure.

At first, you only show the existence and entrance of information.

If it becomes necessary, read the Skill body.

If more detail is needed, read the reference files within the Skill.

If calculation or verification is needed, run a script.

In Claude's Skills, what is loaded at startup is basically metadata such as the Skill's name and description. The Skill body is loaded when that Skill becomes necessary. Furthermore, auxiliary files referenced from the body can also be loaded additionally as needed. Scripts can be executed without putting the code itself into the context, receiving only the results.

For example, a PDF processing Skill would be divided as follows:

pdf-processing/

├── SKILL.md

├── extraction.md

├── forms.md

├── ocr.md

├── validation.md

└── scripts/

├── inspect_pdf.py

└── validate_output.py

In SKILL.md, you don't write all the procedures.

You only write which file to read in which situation.

PDF Processing

For normal text extraction, refer to extraction.md.

Only refer to forms.md if you need to fill out an input form.

Only refer to ocr.md if text extraction fails due to image-centric content.

Verify against the criteria in validation.md before producing the final output.

If Claude is just doing normal PDF extraction, it doesn't need to read the descriptions for OCR or form processing.

This allows you to lighten the current context without cutting the amount of information.

The important thing is not "reducing knowledge."

It's stopping the permanent residency of knowledge.

New Rule 4

From "Writing Important Things Many Times" to "Writing Once in One Place"

Previous models sometimes picked up instructions at the end of the context more strongly than those at the beginning.

Therefore, a design was used where the same command was repeatedly written in the system prompt, CLAUDE.md, Skill, and tool descriptions.

However, duplication of commands has problems.

First, it consumes tokens.

Next, differences are born between commands as expressions change slightly.

Furthermore, only one place is updated, and others remain old.

For example, the system prompt says "Always run tests," the Skill says "Run tests only if there is time," and CLAUDE.md says "Unit tests are enough."

When this happens, the information increased for emphasis makes the judgment ambiguous.

In the new design, a "master copy" is decided for each command.

• Product-wide authority and roles: System prompt.
• Repository-specific exceptions: CLAUDE.md.
• Procedures for specific tasks: Skill.
• How to use tools: Tool description.
• Specifications for current deliverables: Reference files.
• Knowledge discovered in the past: Memory.

Do not duplicate the same information across multiple layers.

This is the same as the Single Source of Truth in software design.

Context engineering is becoming more of an information architecture problem than a writing technique.

New Rule 5

From "Accumulating Memories in CLAUDE.md" to "Dividing Labor Between CLAUDE.md and Auto-memory"

Previously, when there was something you wanted Claude to remember, the method of appending it to CLAUDE.md was used.

However, CLAUDE.md is loaded every time.

If you keep adding debugging information that was useful only once, personal work habits, past fixes, and temporary workarounds, it will quickly become bloated.

Claude Code now has Auto-memory.

It's a division of labor: CLAUDE.md is for permanent instructions written by humans, and Auto-memory is for learnings discovered by Claude itself during work.

Auto-memory stores build commands, things discovered during debugging, architectural insights, coding preferences, work habits, and so on. Claude doesn't save everything; it chooses information it judges will be useful in future conversations. Auto-memory is enabled by default and managed per project.

Don't confuse their roles.

In CLAUDE.md, write things you definitely want Claude to follow.

In Auto-memory, place things Claude has learned from experience.

For example, the following content is suitable for CLAUDE.md:

Do not store amounts as floating-point numbers; always handle them in the smallest currency unit as integers.

This is a project design rule.

On the other hand, the following content is suitable for Memory:

If payment tests fail in the local environment, it's highly likely that an old Webhook process is occupying the port.

This is knowledge discovered during work.

However, you shouldn't trust Auto-memory unconditionally either.

Claude might record a one-time coincidence as a general rule.

Old workarounds might remain even after updates.

Incorrect information might be saved.

Therefore, Memory needs hygiene management.

In the official Claude Fable 5 guide, a design is recommended where one learning is saved in one file, a summary is placed at the beginning, it's not duplicated with existing information, and memories found to be errors are deleted.

Memory is not a graveyard.

It's a place to store hypotheses, learnings, and fix histories in an updatable form.

New Rule 6

From "Simple Text Specifications" to "High-Density References"

In previous AI, it was recommended to summarize specifications in concise Markdown.

Of course, Markdown is still useful.

However, the Claude 5 generation can handle more complex and high-density references.

For example, consider the case of making a web design.

Rather than telling it in text:

Make it white-based, high-end, with wide margins and large headings.

Passing an HTML mockup close to the actual thing can convey the structure, margins, font size, hierarchy, and component relationships with higher accuracy.

Screenshots only show the appearance.

With HTML, it can read the structure, style, values, responsive design, and the meaning of components.

Code is a very high-density instruction language for AI.

The same can be said for tests.

Instead of just writing in the specification:

Reject invalid email addresses.

Place a test like the following:

1it("rejects an address without a domain", async () => {
2  const result = await registerUser({
3    email: "user@",
4    password: "valid-password"
5  });
6
7  expect(result.error.code).toBe("INVALID_EMAIL");
8});

This test includes the input format, function name, return value, error structure, and expected behavior.

Tests are not just a means of verification.

They are executable specifications that Claude can read directly.

• For design: HTML mockups.
• For writing: Approved articles and quality rubrics.
• For APIs: OpenAPI specifications and tests.
• For video: Actual composition code and timelines.
• For spreadsheets: Finished samples and formulas.

In context engineering, it becomes important not just to "write descriptions," but to convert the correct answer itself into a referable form.

New Rule 7

From "Making Claude Reflect on Itself" to "Letting Another Verifier Judge"

From here on, this is my own important conclusion based on this announcement and the official Claude 5 guide.

After letting Claude do a job, just asking the same Claude to:

Please think about whether you made any mistakes.

...is not enough.

The Claude that did the work is pulled toward the premises it adopted, the information it loaded, and its way of thinking.

It's hard to find what you missed while staying in the same context.

So, in the Claude 5 era, you independent the verification.

Let the implementation person only do the implementation.

Pass the specifications, deliverables, and evaluation criteria to a sub-agent with a new, independent context.

Show that sub-agent the actual code, test results, screens, and diffs, rather than the worker's explanation.

Anthropic also states that for long-term tasks, specifying self-verification methods and using an independent verification sub-agent with a new context tends to be more effective than simple self-criticism. Also, in Claude Code best practices, it is explained that it's important to prepare pass/fail judgments that Claude itself can execute, such as tests, builds, and comparison screenshots.

This is the core of loop engineering.

1. Generate.
2. Observe.
3. Compare with criteria.
4. Fix.
5. Verify again.

The strongest context for improving AI quality is not a long command sentence.

It's a mechanism that can observe failure.

Think of Claude 5 Era Context Design in 6 Layers

I would divide the context of Claude Code or a custom AI agent into the following 6 layers:

Layer 1: System Prompt

Here, write the role as a product, authority, relationship with the user, and boundaries that must never be crossed.

If you are making a custom agent, it would be something like this:

You are an execution-type agent that supports user software development. If the user asks for a change, perform the necessary research, implementation, and verification. If it's just a question or consultation, return an evaluation and do not make changes on your own. Proceed autonomously with local reversible operations. Get confirmation for operations whose impact extends to shared environments, such as external publishing, sending, billing, deletion, and deployment. When reporting progress, state only facts that could be confirmed by actual tool results.

Do not write how to write React or the format of commit messages here.

The system prompt is the product's constitution.

It is not a work manual.

Layer 2: CLAUDE.md

Here, write information that is repository-specific and dangerous not to know every time.

For example:

Project

B2B billing management service.

Non-obvious constraints

• Store amounts in the smallest currency unit as integers.
• Do not retrieve customer data without tenant_id.
• Type definitions are aggregated in packages/contracts.
• If you change the DB schema, run the compatibility check Skill.

Project-specific conventions

• Prioritize existing components/ui for UI and do not increase new basic components.
• Use the shared time library for date processing. Do not operate standard Date directly.

On-demand guidance

• Use /release-check for pre-release verification.
• Refer to the payment-safety Skill when changing payment processing.

The important thing is not to write general React explanations, a list of all directories, or dependencies that can be understood by looking at package.json.

The current /doctor detects information that can be derived by looking at the codebase from CLAUDE.md and proposes reducing directory structures, dependency lists, and general architectural descriptions. On the other hand, the policy is to keep pitfalls, design reasons, and conventions that differ from standard tool behavior.

What should be written in CLAUDE.md is not "what Claude can understand by looking."

It's what it can't understand by looking, what's dangerous to misunderstand, and what's intentionally deviating from the standard.

Layer 3: Skill Metadata

The name and description of a Skill are search indices for Claude to find the necessary Skill.

What's important here is the description, even more than the Skill body.

A bad example is:

description: Supports the frontend.

With this, it's unclear when it should be used.

A better example would be:

description: >

Create, fix, and review web screens.

Use when the user asks for LP, dashboard, UI, layout, responsive support,

design improvement, or accessibility.

The description is not an advertisement for the Skill.

It's a router that defines the calling conditions.

Layer 4: Skill Body

In the Skill body, write the minimum policy necessary for Claude to start that work.

Frontend Quality

First, check the existing design system and components.

Before creating a new screen, search for similar screens and match margins, font hierarchy, corner radius, shadows, and form structure.

Do not judge appearance by guess alone; actually launch the screen and check it.

Refer to references/visual-rubric.md for detailed evaluation criteria.

Existing approved designs are in references/approved-pages/.

After changes, run scripts/check-ui.sh.

The body is not an encyclopedia.

It's a map for Claude to judge what to read next and what to execute.

The official guide also recommends keeping the Skill body concise and not repeating general knowledge Claude already knows. Since the Skill body consumes context in subsequent conversations once loaded, you need to question the value of every line.

Layer 5: References and Executable Scripts

Here, place detailed specifications, API documents, approved samples, checklists, rubrics, conversion scripts, and verification code.

It's safer not to make the reference hierarchy too deep.

In a configuration that moves from SKILL.md to advanced.md, then to details.md, and then to another file, there's a possibility Claude will only read halfway.

In the official Skill design guide, a one-level structure where auxiliary files can basically be referenced directly from SKILL.md is recommended.

Layer 6: Auto-memory

Here, save reusable learnings obtained from work.

However, Memory is not the master copy of commands.

If it contradicts CLAUDE.md or the code, design it so the Memory side can be updated or deleted.

Just by separating these 6 layers, context crosstalk will be greatly reduced.

Skills are Not "Long Prompts"

If you think of Skills as just prompt templates, you'll get the design wrong.

A Skill is a folder.

Inside it, you can place short policies, reference materials, scripts, templates, data, and samples.

The important thing is not to make Claude read everything.

It's to create an information space that Claude can explore on its own.

For example, suppose you make a "Skill to write human-like Japanese articles."

A bad Skill writes 100 prohibitions in SKILL.md:

• Don't use "To conclude."
• Don't repeat the same sentence ending.
• Don't increase bullet points.
• Don't make one sentence long.
• Include emotional expressions.
• Include metaphors.
• Avoid AI-like phrasing.
• Don't increase headings too much.

With this, Claude uses its reasoning for checking prohibitions rather than writing the article.

A better structure would be:

human-writing/

├── SKILL.md

├── voice-rubric.md

├── article-structure.md

├── approved-examples.md

├── banned-patterns.md

└── scripts/

└── detect-repetition.py

In SKILL.md, write only the core thinking.

Aim for writing where the reader feels "my understanding has progressed" rather than "it was explained." Don't line up information equally; add pace according to importance. Don't end with just abstract theories; include concrete examples so the reader can imagine the scene. For the rhythm of the text, refer to approved samples. After writing, evaluate with voice-rubric.md and check for repetition of endings and expressions with detect-repetition.py.

Detailed prohibitions are placed in banned-patterns.md only for those where failure was actually confirmed.

You don't write 100 from the start.

You only add failures discovered in evaluation.

In the Claude 5 Era, "Create Evaluations Before Writing Rules"

This is very important.

Many people make a huge Skill first.

After that, they try to see if it works well.

The order is reversed.

First, let Claude without the Skill do a representative job.

Observe where it fails.

Create evaluation cases that reproduce the failure.

Add only the minimum information necessary to the Skill to fix that failure.

Evaluate again.

If it doesn't improve, delete or rewrite it.

In Anthropic's Skill creation guide, the method of creating evaluations before writing detailed documentation, measuring baseline performance without the Skill, and starting with minimum instructions to fill actual gaps is recommended.

This reduces rules for preventing imaginary problems.

Context is not something to add just in case.

It's something to add only when performance improvement can be confirmed.

Ideally, when adding one rule, you should be in a state where you can answer the following questions:

• Which failure does this rule prevent?
• Does that failure occur even with the current model?
• Does adding this rule lower the degree of freedom for other jobs?
• Can the same purpose be achieved with tests or tool design?
• Does it need to be loaded all the time?
• Can it be moved to a Skill or reference file?

Rules that can't answer these will likely become context debt.

New Context Engineering for Article Production

This thinking is very powerful even outside of coding.

For example, when writing long articles with Claude Code.

You don't need to write all the writing rules in CLAUDE.md.

In CLAUDE.md, write only matters of importance specific to the medium.

The main readers are Japanese non-engineers who want to use generative AI for work. Write down to procedures that can actually be tried, not just a summary of generalities. Distinguish between facts and inferences, and confirm primary information for information with currency. As a rule, do not use tables; compare within the flow of the text.

Divide the structure for each type of article into Skills.

• Science articles.
• AI tool explanations.
• Management analysis.
• Psychology articles.
• Long-form research.
• Short text for X.

Furthermore, place details of style, approved articles, prohibited expressions, and citation methods in reference files within the Skill.

Make fact-checking a separate verification Skill.

Let a separate editing agent judge the writing quality.

This allows the Claude writing the article to concentrate on writing.

Accuracy improves more when roles are divided than when one huge "all-purpose writing Skill" is made.

In LP Production, Pass "References Close to the Real Thing" Rather Than Text Descriptions

In LP production, some people give a massive amount of rules like:

• High-end feel.
• White background.
• Many margins.
• Modern.
• Large text.
• Don't make it AI-like.
• Don't use cards too much.
• Gradients are prohibited.

With just this, the "high-end feel" Claude thinks of and the "high-end feel" the user seeks won't necessarily match.

Here, use rich references.

• HTML of approved LPs.
• Design tokens.
• Actual logos.
• Usable font specifications.
• Heading sizes.
• Margin scales.
• Existing components.
• Standards for the mobile version.

Passing the correct design system as code is stronger than writing 100 prohibitions.

After completion, call a Skill that actually displays it in a browser, takes a screenshot, and verifies the difference from the reference design.

Here too, environment over commands.

The Same Happens with HyperFrames and Video Editing

If you write everything about transitions, subtitles, cameras, animations, music, length, margins, colors, and speed into a video production Skill, the Skill will become huge.

Instead, divide the roles.

• Overall video design Skill.
• Subtitle Skill.
• GSAP animation Skill.
• Audio sync Skill.
• Brand expression Skill.
• Rendering verification Skill.

In SKILL.md, place only a map to reach the necessary Skills and reference files.

Place HTML compositions of approved videos as references.

Verify length and subtitle overlap with scripts, not just by being careful in text.

One verification code that fails if subtitles protrude out of the screen is stronger than writing "Don't let subtitles protrude out of the screen" 100 times.

This is the essence of new context engineering.

/doctor Has Become a Context Health Check for Claude Code

Claude Code currently has a diagnostic Skill called /doctor.

This is not just an installation check.

It checks not only duplicate installations, PATH, and broken config files, but also unused Skills, MCPs, plugins, and their context costs.

Furthermore, it finds duplicates between local and repository CLAUDE.md, cuts information Claude itself can infer from the codebase, and makes proposals to move descriptions that don't need to be loaded all the time to Skills or nested CLAUDE.md.

It's a design that presents results and gets confirmation before changes.

claude doctor from the terminal outputs an installation diagnosis in read-only mode without starting a session. /doctor within Claude Code performs wider checks and fix proposals.

In other words, the "decluttering of prompts" that humans used to do manually is starting to be included as a standard feature of Claude Code.

This is a big change.

Instead of increasing settings to make AI stronger, a feature to cut settings to make AI stronger has been installed.

Procedures for Actually Rebuilding Context

If current CLAUDE.md or Skills are bloated, I rebuild them in the following order:

First, collect all context sources.

System prompt, personal CLAUDE.md, project CLAUDE.md, nested CLAUDE.md, .claude/rules, Skills, Auto-memory, MCP, Hooks, and sub-agent settings.

Next, classify each sentence into 6 types:

1. Product policy needed all the time.
2. Repository-specific pitfalls.
3. Procedures for specific tasks.
4. Detailed reference information.
5. Memories obtained from work.
6. Candidates for deletion.

At this point, don't try to fix the sentences beautifully. Just think about the placement.

After that, look for duplicates and contradictions.

Check strong commands like "Always," "Definitely," "Prohibited," "Constantly," and "Never" intensively.

• Is it really correct in all situations?
• Is it necessary even for the current model?
• Is it related to security or irreversible operations?
• Is it just a preference?

Next, move procedures that are loaded all the time to Skills.

Break down long Skills into reference files.

Move processing that can be verified mechanically to scripts.

Delete descriptions that can be understood by looking at the codebase or files.

Finally, choose about 5 representative jobs and compare before and after the change.

• Success rate.
• Number of unnecessary questions.
• Misuse of tools.
• Work time.
• Token consumption.
• Quality of deliverables.
• Rule compliance rate.

Look at these and confirm if it really improved.

Even if problems occur due to cutting, don't immediately return to the old long text.

First, identify which failure occurred.

Add only the minimum instructions, tool design, and verification methods to prevent that failure.

Prompt to Let Claude 5 Diagnose Context

If you are rebuilding a current project for Claude 5, you can use the following instructions:

Please audit the context design of this project for the Claude 5 generation.

Target: - CLAUDE.md - Nested CLAUDE.md - .claude/rules - .claude/skills - subagents - hooks - MCP settings - Auto-memory - Tool descriptions

Purpose: To reduce duplicates, contradictions, excessive constraints, old training wheels, and information that doesn't need to be loaded all the time, while leaving Claude's judgment power.

Do not change files at first; report the audit results.

Classify each item into the following: 1. Always necessary at the system level 2. Repository-specific pitfalls to remain in CLAUDE.md 3. Procedures to move to Skills 4. Detailed information to move to reference files 5. Deterministic processing to convert to scripts or tests 6. Learnings suitable for Auto-memory 7. Candidates for duplication, contradiction, or deletion

Especially check: - Is there information in CLAUDE.md that can be understood by reading the codebase? - Are the same commands written in multiple places? - Are there prohibitive commands that aren't always correct? - Are there excessive procedure specifications for old models? - Is the Skill body too long? - Is the reference hierarchy too deep? - Are you compensating for a lack of tool description by adding massive usage examples? - Are you managing verifiable rules only in text? - Are the boundaries for security, confidentiality, money, deletion, and external publishing maintained?

If you propose deletion or movement, be sure to write the reason and risk.

Finally, design 5 representative evaluation tasks to compare the current configuration with the new configuration. Perform changes after presenting the audit results.

The important point of this instruction is that it doesn't just say "make it short."

It defines the purpose of cutting context, boundaries to remain, destinations, and evaluation methods.

Misunderstanding the New Rules Will Conversely Drop Performance

After hearing this, some people might think they should empty CLAUDE.md and delete all Skills.

That's wrong.

Claude 5 has become smarter, but it doesn't know your company's specific circumstances, customer-specific preferences, special code configurations, or implicit business rules.

What can be deleted due to Claude's improved ability is content that Claude can judge from general knowledge and surrounding information.

What must not be deleted is information that cannot be understood even by looking from the outside.

• Why is the configuration different from the standard?
• Which processing caused a major accident in the past?
• Where is it related to laws or contracts?
• Which operations require human approval?
• What does the customer judge as "good"?
• What are the completion conditions?

If you tell Claude to "judge because you're smart" while hiding the facts necessary for judgment, Claude has no choice but to guess.

Cutting rules and cutting context are different.

Cut unnecessary commands. But increase facts necessary for correct judgment.

This is the true new rule.

Context Engineering Changes from "Commands to AI" to "Workplace Design for AI"

Prompt engineering until now was the technique of writing excellent command sentences.

However, as AI becomes agentic, uses multiple tools, works for a long time, has memory, and delegates work to sub-agents, it cannot be controlled with just one command sentence.

What's needed is the design of the entire environment in which the AI works.

• What to give as common sense?
• What to make it research only when necessary?
• Which tools to show?
• How to express tool choices?
• What to make it remember?
• What to guarantee with tests?
• Where to put in another verifier?
• Which operations require human approval?

The job of designing these is context engineering.

And if I were to put Claude 5 era context engineering into one formula, I would think of it as follows:

Effective Context Quality

= (Relevance × Appropriate Disclosure Timing × Clarity of Authority × Verifiability)

÷ (Duplicates × Contradictions × Outdatedness × Noise)

Just increasing information will increase both the numerator and the denominator.

The important thing is to increase the density of necessary information and reduce unnecessary friction.

Strong People from Now on are Not Those with Long Prompts

Before Claude 5, people who added rules every time the AI failed were considered strong.

From now on, it's the opposite.

When a failure occurs, people who can classify the cause instead of immediately adding a command will become strong.

• Is it a lack of information?
• Is the tool design bad?
• Is the resolution of the reference material low?
• Is there no evaluation criteria?
• Is the Memory old?
• Are multiple commands conflicting?
• Are you taking away judgments that should be left to the model?
• Does a verification loop not exist?

People who can see through this will maximize the performance of AI agents.

The ability to write prompts is, of course, necessary.

However, what becomes even more important is the ability to classify and hierarchize information, design calling conditions, and change it into a verifiable form.

In AI utilization from now on, writing ability alone is not enough.

Information design, tool design, evaluation design, and memory design are necessary.

Summary

What is happening in the Claude 5 generation is not an update of prompt techniques.

It is a change in the relationship with AI itself.

Previous AI was a newcomer who was dangerous unless instructed in detail.

Current Claude 5 is approaching an existence that can read intent from ambiguous situations, search for necessary information, delegate multiple tasks, and continue long-term work.

If you keep making that partner read tens of thousands of characters of manuals for old newcomers, you won't be able to draw out its ability.

From now on, don't increase rules; create an environment where it can judge.

Don't increase examples; create an easy-to-understand interface.

Don't make it read everything first; disclose it at the necessary moment.

Don't save everything to CLAUDE.md; separate instructions and memory.

Don't explain specifications only in text; pass high-density references such as code, tests, HTML, and rubrics.

Don't rely only on Claude's own reflection; prepare independent verifiers and executable evaluations.

And periodically audit whether rules made for past models are taking away the judgment power of the current model.

The most dangerous thing in the Claude 5 era is not a lack of prompts.

It is continuing to bind smartened AI with old context.

The new rule of context engineering boils down to one thing:

Don't command everything to Claude; design a world where Claude can think correctly.

This is the new work style in the era of Claude 5 and the AI agents beyond.