Claude 5 Context Engineering Guide: CLAUDE.md, Skills, Memory and Agent Tools

The short version: Claude 5 does not need a larger pile of permanent instructions. It needs a cleaner context architecture: a small set of durable rules, well-designed tools, on-demand skills, trustworthy references, and memory that is retrieved only when relevant.

That is the practical lesson behind a widely shared July 24 article from Anthropic engineer Thariq Shihipar. He says Anthropic removed more than 80% of Claude Code’s system prompt for newer models such as Claude Opus 5 and Claude Fable 5, without a measurable decline on its coding evaluations. This is an important result, but it is easy to misread. It does not mean prompts no longer matter. It means the work has moved from writing more instructions to designing the full information environment in which an agent operates.

This guide translates that shift into a usable architecture for Claude Code, the Claude API, custom agents, and long-running business workflows. It also reconciles Shihipar’s field guidance with Anthropic’s current documentation, including where examples still help, when rules need deterministic enforcement, and how to decide whether information belongs in a system prompt, CLAUDE.md, a Skill, auto memory, a reference file, a tool schema, or a hook.

My practical takeaway: The best Claude 5 context is not the most complete context. It is the smallest high-signal working set that still gives the model the authority, evidence, interfaces, and boundaries it needs to finish the task.

What changed in Claude 5 context engineering?

Prompt engineering optimizes the instructions in a request. Context engineering optimizes everything the model can see when it decides what to do: the system prompt, user message, conversation history, loaded files, tool definitions, tool results, Skills, memory, retrieved documents, examples, and summaries from other agents.

Anthropic describes this as the evolution from finding the right wording to curating the right tokens. Its official context-engineering guide argues that context is a finite attention budget. A million-token window can hold a great deal of text, but capacity is not the same as reliable attention. Irrelevant, duplicated, stale, or contradictory material can still make an agent slower and less consistent.

Claude 5 raises the importance of this distinction. The newer models have stronger judgment, tool use, long-horizon planning, self-correction, and instruction following. Rules that compensated for older model weaknesses can now become constraints the model must reason around. Repeated verification instructions can trigger unnecessary checking. Tool examples can accidentally narrow exploration. Huge instruction files can compete with the task itself.

In other words, a better model does not make context engineering obsolete. It changes what good context engineering looks like.

The 80% system-prompt reduction: what it proves and what it does not

Shihipar’s Claude 5 context-engineering article on X reports an internal Anthropic observation: Claude Code’s system prompt was reduced by more than 80% for newer models without a measurable loss on Anthropic’s coding evaluations.

There are three responsible ways to interpret that claim.

• It is model- and harness-specific. This was about Anthropic’s own Claude Code system prompt and evaluations, not a universal guarantee that every team can delete four-fifths of every prompt.
• It is evidence for removing redundant scaffolding. Claude 5 can often infer ordinary engineering judgment that older models needed spelled out.
• It does not eliminate the need for precise constraints. Product scope, safety boundaries, permissions, legal requirements, and non-obvious repository conventions still need to be expressed—or enforced outside the prompt.

The correct exercise is therefore not “delete 80%.” It is “identify which 80% is duplicate, derivable, stale, over-prescriptive, or stored at the wrong layer.” Your own evals decide the final number.

The six new rules of context engineering for Claude 5

Older pattern	Claude 5 pattern	What to do
Write rules for every situation	Give judgment at the right altitude	State the outcome, important boundaries, and decision criteria; let the model handle routine choices.
Teach tool use through many examples	Design a legible interface	Use clear names, narrow responsibilities, typed parameters, useful enums, and concise results.
Load all guidance up front	Use progressive disclosure	Keep only universal context always loaded; retrieve procedures and references when their trigger appears.
Repeat instructions in several places	Give each rule one canonical home	Put tool-specific behavior in the tool description, task playbooks in Skills, and always-on conventions in CLAUDE.md.
Use CLAUDE.md as memory and manual	Separate instructions from learned memory	Keep human-authored rules in CLAUDE.md; allow auto memory to retain learned patterns and corrections.
Describe a simple specification	Provide high-fidelity references	Point Claude to code, tests, schemas, mockups, artifacts, or rubrics that embody the desired result.

1. Replace blanket rules with bounded judgment

Older agent prompts frequently include absolutes such as “never add comments,” “always create a plan,” or “verify every non-trivial task with a second agent.” These rules are attractive because they are easy to write. They are also wrong for some tasks.

The Claude 5 alternative is not vagueness. It is a higher-quality decision rule. “Match the surrounding code’s comment density, naming, and idiom” gives the model a local standard it can inspect. “Delegate only when the workstreams are independent and substantial” defines when coordination cost is justified. “Ask only when different answers would materially change the result” separates important ambiguity from routine judgment.

This aligns with Anthropic’s current Opus 5 prompting guidance. Opus 5 already performs substantial self-verification. Legacy prompts that demand another verification pass can increase token use and latency without improving the result. The same documentation warns that Opus 5 may broaden a task, so a concise scope boundary remains valuable.

2. Design tools as interfaces, not tutorials

Earlier models often benefited from several examples showing how to call a tool. With newer models, a long example set can confine the model to the paths you anticipated. A well-designed schema communicates more efficiently.

A strong tool has one clear purpose, a name that describes the action, parameters that distinguish meaningful choices, and results that return only decision-relevant information. An enumeration such as pending | in_progress | completed communicates a state machine without a paragraph of prose. A constraint such as “at most one item may be in progress” defines the required invariant.

This does not mean examples are obsolete. Anthropic’s general prompting documentation still recommends examples for canonical outputs, style, and difficult edge behavior. The narrower lesson is that examples should demonstrate the result you care about—not compensate for an ambiguous tool contract.

3. Move from upfront loading to progressive disclosure

Progressive disclosure means showing Claude a useful index first and letting it load depth when the task requires it. A short Skill description can tell Claude when a workflow is relevant. The Skill can then route to a reference file, template, or script. A lightweight memory index can point to topic-specific notes. A repository tree can reveal where the implementation truth lives.

This is more than token saving. It reduces instruction collisions. A database migration playbook does not need to compete with frontend design guidance during a CSS task. A publishing checklist does not need to occupy attention during research. The model receives the right procedure near the moment it can act on it.

Claude Code’s official Skills documentation follows this architecture: descriptions are available for discovery, while the full SKILL.md body loads when the Skill is used. Supporting files can hold detailed references, examples, templates, and scripts.

4. Stop repeating the same instruction

If a tool description, system prompt, CLAUDE.md, Skill, and user prompt all describe the same behavior differently, the agent must reconcile five versions of the rule. Repetition feels like emphasis to a human writer; to an agent it can be duplicated context or a subtle conflict.

Assign one owner to each instruction:

• Product identity and universal behavior belong in the system prompt.
• Repository-wide conventions and non-obvious gotchas belong in CLAUDE.md.
• Repeatable procedures and deep reference material belong in Skills.
• Tool-specific usage belongs in tool names, descriptions, schemas, and returned metadata.
• Non-negotiable enforcement belongs in permissions, validators, or hooks—not merely prose.

5. Separate human instructions from agent memory

Claude Code now distinguishes between CLAUDE.md, which you author, and auto memory, which Claude builds from recurring corrections, preferences, commands, and discoveries. Anthropic’s memory documentation recommends using the former for durable instructions and the latter for learned patterns.

This separation prevents a common failure: turning CLAUDE.md into an append-only transcript of everything the project has ever taught the agent. Learned debugging details and evolving discoveries can live in topic files. A concise MEMORY.md acts as an index, while deeper material is read on demand.

DMT has previously covered this evolution in Claude Code’s auto-memory architecture. The context-engineering implication is straightforward: memory is useful when it preserves high-value state outside the active window, not when every historical note is injected into every request.

6. Prefer executable or inspectable references

When your desired result is hard to describe, a reference often carries more information than another page of adjectives. Source code can encode behavior precisely. Tests can define acceptance criteria. A schema can expose relationships. An HTML prototype can communicate structure and interaction. A rubric can define taste or quality in a form that a verifier can apply.

Shihipar’s Fable 5 field guide makes the broader point: long-horizon performance becomes limited by the unknowns in the user’s specification. References help surface “unknown knowns”—requirements you recognize when you see them but did not know how to articulate in advance.

Where each piece of context should live

Layer	Best use	What should not live there
System prompt	Product role, global behavior, stable safety and interaction boundaries	Repository details, one-off task steps, giant tool manuals
CLAUDE.md	Build commands, project conventions, unusual architecture decisions, recurring gotchas	Facts Claude can cheaply derive, rare procedures, long reference manuals
Path-scoped rules	Language-, package-, or directory-specific guidance	Rules that must apply to the entire repository
Skills	Repeatable workflows, domain knowledge, checklists, templates, routed references	Always-on facts or deterministic enforcement
Auto memory	Learned preferences, debugging insights, recurring corrections, continuity across sessions	Secrets, unverified assumptions, permanent policy
Reference files	Specifications, code, tests, mockups, evidence, detailed documentation	Instructions that must be visible before Claude knows which file to open
Tool schema	What an action does, its parameters, constraints, and compact output shape	Unrelated workflow policy
Hooks and validators	Formatting, security blocks, mandatory checks, event-triggered enforcement	Judgment-heavy guidance that needs interpretation

Use a complete task contract—without creating a context dump

Simplifying permanent context does not mean underspecifying the task. For difficult work, Claude Opus 5 performs best when it can see the complete task contract before it starts: the outcome, relevant context, scope, evidence hierarchy, allowed tools, acceptance checks, and stop condition.

1. Outcome: define the observable result, not a vague activity.
2. Context: name the repository, documents, audience, baseline, and prior decisions that matter.
3. Scope: state what is included and what is intentionally excluded.
4. Evidence: identify which sources or files outrank inference and how uncertainty must be labeled.
5. Tools and permissions: distinguish inspection, local editing, external drafts, and live mutation.
6. Acceptance checks: name tests, reconciliations, citations, visual checks, or review criteria.
7. Handoff: specify the files, receipts, remaining risks, and stop condition.

Outcome
Implement JSON export and leave it ready for review.

Context
The current exporter supports CSV. Existing tests and public interfaces are authoritative.

Scope
Touch only the exporter, its tests and documentation. Do not change authentication,
publish a release or reformat unrelated files.

Evidence and permissions
You may inspect and edit local files and run existing tests. If the request conflicts
with an interface or test, report the conflict before changing the contract.

Acceptance
- Existing CSV tests pass.
- JSON round-trip and invalid-input tests pass.
- Documentation includes one minimal example.

Handoff
Lead with the outcome, list changed files and exact test results, then stop.

This is complete context because every item can change the work. A directory tour, generic framework explanation, and unrelated historical logs would be a context dump because Claude can derive or retrieve them when necessary.

How to write a Claude 5-ready CLAUDE.md

Anthropic’s current guidance is to keep CLAUDE.md concise—roughly under 200 lines—and prioritize information Claude cannot reliably infer from the repository. Files are loaded in full, so a well-organized 600-line file still consumes the same context as a disorganized one. Splitting it into imported files can improve maintainability, but imports loaded at launch do not save context.

A useful CLAUDE.md answers five questions:

1. What is this repository and where are its real boundaries?
2. Which commands are canonical for build, test, lint, and local execution?
3. Which conventions differ from the defaults a competent engineer would assume?
4. Which mistakes are costly, recurring, or difficult to detect from code alone?
5. Where should Claude load deeper guidance when a specific task appears?

A bloated version

# Project
This repository contains a Next.js application. Next.js is a React framework...

# Rules
- Always add comments.
- Never add comments unless necessary.
- Always make a plan.
- Always verify every task twice.
- Use the API correctly. Here are 18 examples...

A better Claude 5 version

# Repository
Customer portal for two regulated markets. The API and UI deploy independently.

# Canonical commands
- Install: pnpm install --frozen-lockfile
- Unit tests: pnpm test
- Contract tests: pnpm test:contracts

# Non-obvious constraints
- Public API types live only in packages/contracts; do not duplicate them in apps.
- Migrations must remain backward compatible for one release because deploys are staggered.
- Match the surrounding module's comment density and naming conventions.

# Routed guidance
- Database migrations: load .claude/skills/migration/SKILL.md
- Release verification: use /release-check

Notice what disappeared: dependency summaries, directory listings, generic programming advice, duplicated style rules, and procedures that matter only occasionally. Claude can inspect the repository for the first two and load a Skill for the last.

Claude Code’s /doctor command can now help identify reducible material in a checked-in CLAUDE.md. Anthropic says the check looks for information the model can derive from the codebase—such as directory layouts and dependency lists—while preserving conventions, rationale, and pitfalls. Treat its suggestions as an audit, then validate the smaller file on representative tasks.

How to design Skills for progressive disclosure

A Skill should behave like an excellent index and operating guide, not a data warehouse. Its description must make the trigger obvious. The main body should contain the rules that matter throughout the workflow. Detailed sources, examples, templates, and scripts should sit in supporting files with clear routing instructions.

.claude/skills/publish-release/
├── SKILL.md              # Trigger, workflow, decision gates
├── references/
│   ├── release-policy.md # Detailed policy
│   └── rollback.md       # Loaded only when rollback is relevant
├── templates/
│   └── release-notes.md
└── scripts/
    └── verify-release.sh

Three design rules matter most:

• Make descriptions distinct. If three Skills all say they “help with deployments,” Claude has no reliable routing signal.
• Put the most important instructions first. Invoked Skills survive compaction only within token budgets; recent Skills are favored and long bodies may be truncated.
• Use code for deterministic work. If a step can be validated by a script, provide the script instead of asking the model to remember a long manual checklist.

The architecture resembles the practical system described in our guide to reusable AI workflows and plugins: compact instructions route the agent toward the right capability, while the depth stays outside the default context until needed.

Tool design is now a context-engineering problem

Tool definitions occupy context before a tool is called, and tool results accumulate after calls. A large agent can therefore lose a surprising amount of its working window to schemas and logs that are irrelevant to the current decision.

Anthropic’s Tool Search documentation gives two useful reference points. Loading a typical multi-server toolset can consume roughly 55,000 tokens before work begins. Tool Search often cuts that initial definition load by more than 85%, while also narrowing the model’s selection set. Anthropic notes that selection quality can deteriorate when more than roughly 30–50 tools are exposed at once.

For custom agent builders, the solution depends on where context is being spent:

• Too many schemas: defer tools and load them through Tool Search.
• Too many small tool-result turns: use programmatic tool calling so intermediate data can be processed without entering the conversation.
• Stable definitions repeated across requests: use prompt caching to reduce cost, while remembering that caching does not reduce attention load.
• Old results crowding a long conversation: use context editing to clear results that have served their purpose.

The larger principle is simple: a tool should return what the agent needs for the next decision, not every field the underlying API happens to expose.

Memory, compaction, and subagents: three different jobs

These mechanisms are frequently grouped together, but they solve different context failures.

Memory preserves durable state

Use memory for decisions, preferences, discoveries, and continuity that should survive a new session. Keep the startup index compact and route to deeper notes. Audit it because learned memory can become stale or encode a mistaken assumption.

Compaction preserves a running task

Compaction summarizes a conversation that is approaching its context limit. It should retain decisions, unresolved problems, modified files, test state, and next actions while discarding redundant tool results. It is continuity, not a permanent knowledge base.

Subagents isolate expensive exploration

A subagent gets a separate context window, explores a bounded problem, and returns a compressed result. This is valuable when a task requires many file reads, searches, or independent investigations whose intermediate traces would distract the main agent.

Claude 5’s stronger orchestration makes this pattern more powerful, but not free. Anthropic’s Opus 5 guidance warns that the model delegates readily. Use subagents for genuinely independent workstreams, not as ritual reviewers for simple tasks. For broader context on the agent pattern, see our explanation of agentic AI workflows.

Why “give Claude examples” and “design interfaces” are not contradictory

One apparent conflict deserves attention. Anthropic’s 2025 context-engineering guide strongly recommends curated examples. Shihipar’s 2026 Claude 5 article says the newer approach is to design interfaces rather than rely on tool-use examples.

Both can be correct because they address different failure modes.

• Use a schema or interface to communicate available actions, legal inputs, state transitions, and tool semantics.
• Use examples to demonstrate a hard-to-describe output standard, a canonical edge case, tone, or taste.
• Avoid using dozens of examples as an informal programming language that tries to enumerate every future situation.

The test is whether the example expands understanding or restricts exploration. If the model can derive correct behavior from a clean contract, the example is probably unnecessary. If reviewers keep rejecting the output because “good” is hard to verbalize, a carefully chosen reference or example may be the highest-signal token you can add.

Claude 5 model-specific adjustments

Claude Opus 5

Opus 5 is designed for complex agentic and enterprise work. Anthropic says it is strong at completing end-to-end tasks, finding real bugs, operating across long contexts, and coordinating subagents. It also self-checks heavily. Remove inherited instructions that demand repeated verification, cap unnecessary delegation, define narrow scope when scope expansion would be costly, and specify user-facing verbosity separately from thinking effort.

For model-selection evidence, use DMT’s Claude Opus 5 benchmark and pricing comparison. Context engineering answers a different question: which prompt, tools, files, memory, and references should the selected model receive in the first place?

Claude Fable 5

Fable 5 is optimized for ambitious, long-running work where the main bottleneck can become the user’s unspoken assumptions. Begin with a blind-spot pass, identify known and unknown requirements, prototype when taste is difficult to specify, and provide high-fidelity references. This is especially important for research, design, migrations, and multi-stage knowledge work.

If model choice is part of your architecture, our Fable 5 vs Sonnet 5 comparison offers a task-routing framework for marketing, research, analytics, and agentic workflows.

Claude Sonnet 5

Sonnet 5 brings stronger agentic behavior at a lower price tier, but Anthropic’s documentation emphasizes literal instruction following. Remove stale instructions and contradictions before blaming the model. Define the intended behavior positively, calibrate verbosity, and remeasure token budgets because Sonnet 5 uses a new tokenizer.

Choose effort like an engineering parameter

Context design and compute allocation solve different problems. A poor specification does not become reliable merely because the model thinks longer. Start with a sensible effort level, evaluate the result, and escalate only when a named failure needs more reasoning.

Effort	Useful starting point	Decision rule
Low	Extraction, formatting, routine edits, first-pass review	Escalate only if an acceptance check fails or material ambiguity remains.
Medium	Normal coding, synthesis, structured analysis	Often the best cost-quality point; compare it with high on your own tasks.
High	Difficult implementation, research, professional knowledge work	Use as a robust starting point, then step down if quality holds.
xHigh	Complex debugging, architecture, long agentic work	Keep only if local evaluations show a meaningful gain in accepted outcomes.
Max	Highest-stakes, bounded problems with room for long reasoning	If quality does not improve, redesign context, tools, or decomposition instead.

Anthropic’s Opus 5 guidance emphasizes that effort controls thinking depth, not reliably the visible length of the answer. Prompt for concise progress updates and deliverable length separately. The model’s self-verification and delegation tendencies also mean that more effort can multiply unnecessary work when old harness rules remain in place.

Verification: ask for evidence, not repeated confidence

Removing “double-check everything” from a prompt does not mean removing acceptance criteria. It means replacing a vague request for caution with an observable test.

Weak instruction	Stronger external check
Double-check that the code works	Run the named unit and integration tests and report the exact commands and results.
Make sure every fact is accurate	Link every time-sensitive claim to a primary source and label inference.
Verify the spreadsheet	Reconcile analysis totals to the source export and flag any non-zero difference.
Check the UI carefully	Test the specified actions at desktop and 390-pixel mobile widths.
Ensure nothing was missed	Compare the final artifact against the enumerated acceptance criteria.

A second agent is not automatically independent verification. It improves confidence only when it receives different evidence, a separate hypothesis, or a genuinely adversarial rubric. Otherwise it can repeat the first agent’s assumption at additional cost.

Cost controls that preserve quality

• Route by difficulty. Use the least expensive model that passes representative evaluations; reserve higher-capability models for the hard tail.
• Set an effort ceiling. Escalate after a named failure, not because the task feels important.
• Cap delegation. Specify the maximum number of subagents and give them independent scopes.
• Control deliverable length. Define the audience, required sections, and an approximate length separately from reasoning effort.
• Cache stable prefixes. Prompt caching reduces repeated input cost, although it does not remove those tokens from the model’s attention.
• Trim stale outputs. Clear terminal logs, fetched pages, and tool results after they have served their decision.
• Prefer deterministic checks. A test runner, schema validator, or SQL reconciliation is cheaper and stronger than another paragraph of self-assurance.
• Measure cost per accepted result. Include retries and human correction time, not token price alone.

For subscription-side constraints, DMT’s Claude rate-limits guide explains why conversation length, attachments, tools, model choice, and effort all influence consumption. For asynchronous workflows, the Claude Code Channels guide covers the delivery layer; remote convenience should never broaden the underlying permissions.

When prompt rules are still the wrong enforcement layer

More capable models use judgment better, but judgment is not a security control. CLAUDE.md and Skills are context, not guaranteed configuration. If an action must never happen, enforce that boundary in the harness.

Examples include denying reads of credential files, preventing production deletion, requiring approval before deployment, validating structured payloads, running a linter after edits, or blocking a publish when required metadata is missing. Claude Code hooks, permission rules, schemas, CI checks, and API-side validation are better suited to these jobs.

A useful rule of thumb is:

If the model should interpret the rule, put it in context. If the system must enforce the rule every time, put it in code.

A 30-minute Claude 5 context audit

1. Measure the baseline. Run a small set of representative tasks and record quality, latency, token use, tool errors, and corrections.
2. Map every context source. List system instructions, CLAUDE.md files, rules, Skill descriptions and bodies, MCP tools, memory, startup scripts, and injected references.
3. Find collisions. Search for repeated, conflicting, absolute, or obsolete instructions.
4. Delete derivable facts. Remove directory tours, dependency lists, and architecture summaries Claude can inspect cheaply.
5. Route specialist depth. Move procedures and reference material into focused Skills or path-scoped rules.
6. Improve interfaces. Rename ambiguous tools, narrow their responsibilities, add meaningful enums, and trim verbose results.
7. Move enforcement into code. Replace critical “never” instructions with permissions, hooks, validators, or approvals.
8. Audit memory. Remove stale notes, separate the index from topic files, and verify that no sensitive data is being retained unintentionally.
9. Use /doctor and /context. Inspect what actually loads and review Claude Code’s optimization suggestions.
10. Re-run the same evaluation. Keep the smaller architecture only if adherence and task quality hold.

Common migration mistakes

Deleting specificity instead of deleting redundancy

“Use judgment” is not a substitute for business requirements. Preserve non-obvious constraints, acceptance criteria, permissions, and definitions of done.

Moving a giant CLAUDE.md into one giant Skill

This changes the loading time but not the quality of the information. Split the workflow into a concise entry point and routed references with distinct triggers.

Keeping every tool available just in case

Large tool catalogs consume tokens and create ambiguous choices. Defer uncommon tools and keep the always-loaded set minimal.

Using more agents as a universal quality setting

Multi-agent workflows are excellent for independent research, competing hypotheses, and adversarial review. They are wasteful when one agent can finish the task in a few calls. Anthropic’s dynamic workflows guide makes the same trade-off explicit: parallelism and specialization must justify their token and coordination cost.

Treating a large context window as permission to load everything

A larger window increases capacity, not relevance. Context rot, distraction, stale data, and contradictory instructions remain possible. Retrieval and curation still matter.

The practical bottom line

Claude 5 changes the economics of instruction. The model can supply more ordinary judgment, so teams can spend fewer tokens micromanaging behavior and more effort designing high-quality interfaces, references, evaluation criteria, and enforcement.

The winning architecture is layered:

• a compact system prompt for product identity and universal behavior;
• a short CLAUDE.md for repository-specific facts and gotchas;
• Skills and path-scoped rules for specialist guidance;
• auto memory for learned continuity;
• references for high-fidelity intent;
• well-designed, progressively loaded tools;
• subagents for context isolation when the task earns it; and
• hooks and validators for rules that cannot be left to judgment.

The final step is evaluation. Anthropic’s 80% reduction is a compelling direction, not a number to copy. Start with the strongest current model, remove one layer of scaffolding at a time, and keep the simplest context architecture that passes your real work.

Frequently asked questions

What is context engineering?

Context engineering is the practice of selecting, structuring, retrieving, and maintaining all information available to a model during inference. It includes prompts, tools, memory, message history, documents, examples, and agent summaries—not just the wording of the user’s request.

Is context engineering replacing prompt engineering?

No. Prompt engineering remains one component of context engineering. The broader discipline also decides what should be loaded, when it should be retrieved, how tools communicate their capabilities, what should persist in memory, and what should be enforced outside the model.

How long should CLAUDE.md be?

Anthropic recommends keeping it concise and uses roughly 200 lines as a practical threshold. Shorter files tend to produce better adherence. Move task-specific procedures into Skills or path-scoped rules, and remove facts Claude can easily infer from the repository.

Should I remove examples from Claude 5 prompts?

Remove examples that merely compensate for unclear interfaces or enumerate many hypothetical tool paths. Keep a small number of diverse, canonical examples when they communicate a difficult output standard, edge case, style, or rubric more efficiently than prose.

What should go in a Claude Code Skill?

Put repeatable workflows, specialist knowledge, templates, and task-specific checklists in Skills. Keep the main SKILL.md focused and route detailed material to supporting files or scripts that Claude loads when needed.

Does a one-million-token context window remove the need for curation?

No. A large window expands capacity, but irrelevant and conflicting material can still consume attention, increase cost, and reduce consistency. Progressive disclosure and context editing remain useful even with very long contexts.

Can CLAUDE.md enforce safety rules?

It can guide behavior, but Anthropic explicitly describes it as context rather than guaranteed enforcement. Use permission controls, hooks, validation, sandboxing, and approval gates for boundaries that must hold deterministically.

---

Research note: This independent analysis was written by Tayeeb Khan for Digital Marketer Tayeeb and fact-checked on July 25, 2026. Product behavior was checked against Anthropic’s official engineering article, Claude Platform documentation, Claude Code documentation, and first-party Claude blog posts. The “more than 80%” system-prompt reduction is attributed specifically to Thariq Shihipar’s July 24 field report; Anthropic has not published the underlying evaluation dataset in the linked documentation.