What is context engineering?

Context engineering is the discipline of systematically designing input prompts, system messages, and code context so that AI models perform given tasks accurately. It involves not just inserting long explanations, but structuring information to guide proper reasoning and preventing contamination.

How can I implement prompt chaining in Claude 5th generation?

Prompt chaining is a technique that breaks a complex task into multiple steps and links them so that the output of one step becomes the input of the next. For example, you can design prompts in the sequence of code draft generation, self-review, and test case creation, and include Karpathy's self-check rules as system messages at each step to improve accuracy.

How do I prevent context pollution in vibe coding?

Context pollution is a phenomenon where unnecessary or outdated information accumulates, clouding the model's judgment. You can prevent it by periodically resetting the conversation and reinjecting only essential context, or by performing cross-validation with multi-agent patterns. Additionally, it's important to document the assumptions of generated code and pass them to the next session.

What are Karpathy's new 10 rules?

Karpathy's CLAUDE.md 10 rules, released in June 2026, include new entries such as applying the self-check protocol during code generation, asking about ambiguous requirements, and explaining the reasoning process. Notably, rules that encourage the AI to test its own code and detect logical errors are gaining attention.

How can I efficiently manage context in large codebases?

Use chunking strategies to divide code into functions or files, and dynamically include only relevant chunks in the context via vector embedding-based search. Tools like Claude Code analyze dependency graphs to automatically construct optimal context, and manually adding a list of key files can further enhance accuracy.

New Rules of Context Engineering for Claude 5th Generation Models

md-logJuly 27, 20266 min read

Explore context engineering strategies to maximize the expanded context window of Claude 5th generation models and improve accuracy in vibe coding. From Karpathy's 10 rules, prompt chaining, chunking, to verification patterns, this guide is packed with practical insights.

In 2026, as vibe coding has become a new paradigm in software development, maximizing the performance of AI coding tools is more important than ever. Particularly with the emergence of Claude 5th generation models, context windows have dramatically expanded and memory management capabilities have improved, elevating 'context engineering' beyond simple prompt writing to a core competency. The recent expansion of Andrej Karpathy's CLAUDE.md rules to 10 and the introduction of a self-check protocol clearly illustrate this trend. In this article, we analyze evolved context techniques centered on Claude 5th generation and present practical design strategies to simultaneously enhance AI coding accuracy and productivity.

1. Evolution of Context Windows and Memory: The Advent of the 200K Token Era

Claude 5th generation models have significantly expanded context windows compared to previous generations, capable of stably processing over 200K tokens. This volume is so vast that it can accommodate the entire codebase of a small project at once. However, simply loading more context does not linearly improve model performance. On the contrary, injecting unnecessary information can cause 'context pollution', potentially leading the model to overlook the core issues.

In the five future job archetypes recently proposed by Boris Cherny, creator of Claude Code, roles like 'Context Curator' are emphasized. This suggests that the skill of selecting information the model should focus on from vast contexts and maintaining crucial context like memory is becoming increasingly specialized. In practice, Claude Code already provides intelligent memory management features that automatically index the codebase and load high-priority files into context as the project scales.

2. Prompt Chaining and System Messages: The Power of the Self-Check Protocol

In June 2026, Karpathy expanded his CLAUDE.md file with numerous new rules, reaching a total of 10. The most notable is the 'Self-Check Protocol'. This rule encourages AI agents not only to generate code but also to monitor their own reasoning process, verify assumptions, and proactively detect potential errors.

Applying this to real-world prompt chaining allows designing multiple steps that cross-validate each other. For example, after generating a code draft with the first prompt, you can instruct in the second prompt: "You are a senior reviewer. Check whether the previously generated code violates any security policies and suggest corrections." By specifying such roles and verification procedures in system messages, you can maintain consistent quality. Additionally, Karpathy's rule "If there is an ambiguous requirement, always ask questions" is effective in preventing loss of clarity during prompt chaining.

3. Chunking and Indexing Strategies for Large Codebases

When a project reaches thousands of files, processing the entire context at once is inefficient and costs rise sharply. At this point, 'chunking' and 'indexing' strategies become necessary. Chunking divides the codebase into meaningful units such as functions, classes, or file paths, and generates summaries for each chunk, allowing the model to quickly reference only the relevant parts.

Modern tools like Claude Code analyze the project to build a dependency graph among symbols and dynamically load the chunks most relevant to the developer's query. For instance, if asked "Write test code for the payment module," only the payment-related files are inserted into the context. In this process, semantic search using vector embeddings may also be employed. Developers can trust these automation features, but sometimes manually specifying a list of important context files can significantly improve the accuracy of the final result.

4. Integrating Context Engineering Principles into Vibe Coding Workflows

Vibe coding emphasizes rapid prototyping through conversation with AI, but as pointed out in a July 2026 article by GovTech, a defined process is indispensable for creating sustainable products. Context engineering principles serve exactly as that bridge.

In practice, integration can be done as follows: First, before starting a coding session, inject the project's core architecture and business requirements as system prompts. During the session, design prompts so that the AI outputs a context summary alongside the generated code, explaining the assumptions under which the code was written. At the end of the session, save this summary and use it as the initial context for the next session, ensuring seamless continuity. This works similarly to a developer reading onboarding documents when joining a new team.

5. Verification Patterns for Preventing Context Pollution and Reducing Hallucinations

Context pollution is when a model fixates on outdated conversation history or incorrect example code, leading to erroneous results. To prevent this, first, use a 'context reset' strategy by periodically resetting the conversation and reinjecting only the essential context. Second, employ a multi-agent pattern where the output of one model is verified by another model or by a different role of the same model.

Karpathy's self-check protocol takes this a step further by training a single agent to discover its own errors. For example, include a rule in the system message: "After completing the code, create test cases yourself to check whether the code handles all edge cases." This can proactively reduce the likelihood of hallucinations. Additionally, human-in-the-loop review serves as the final safety net. Establishing a process where humans systematically review and archive AI-generated code and decision-making processes can further enhance reliability.

Conclusion: The Evolving Landscape of Context Engineering

As high-performance models like Claude 5th generation become ubiquitous, context engineering is no longer optional but an essential competency. Karpathy's new rules and various verification patterns demand a shift from simple prompt writing to a mindset of designing collaboration with AI. In this trend, efficiently reviewing and version-controlling the massive work logs left by AI is gaining importance. If you wish to build a more systematic human-in-the-loop review, consider tools like md-log, which records immutable versions upon each save, preserving collaboration history. We hope you continue to update your own context engineering rules amidst the ever-changing technological landscape.

References

#context engineering #Claude #vibe coding #prompt design #AI agent

Frequently asked questions

What is context engineering?: Context engineering is the discipline of systematically designing input prompts, system messages, and code context so that AI models perform given tasks accurately. It involves not just inserting long explanations, but structuring information to guide proper reasoning and preventing contamination.
How can I implement prompt chaining in Claude 5th generation?: Prompt chaining is a technique that breaks a complex task into multiple steps and links them so that the output of one step becomes the input of the next. For example, you can design prompts in the sequence of code draft generation, self-review, and test case creation, and include Karpathy's self-check rules as system messages at each step to improve accuracy.
How do I prevent context pollution in vibe coding?: Context pollution is a phenomenon where unnecessary or outdated information accumulates, clouding the model's judgment. You can prevent it by periodically resetting the conversation and reinjecting only essential context, or by performing cross-validation with multi-agent patterns. Additionally, it's important to document the assumptions of generated code and pass them to the next session.
What are Karpathy's new 10 rules?: Karpathy's CLAUDE.md 10 rules, released in June 2026, include new entries such as applying the self-check protocol during code generation, asking about ambiguous requirements, and explaining the reasoning process. Notably, rules that encourage the AI to test its own code and detect logical errors are gaining attention.
How can I efficiently manage context in large codebases?: Use chunking strategies to divide code into functions or files, and dynamically include only relevant chunks in the context via vector embedding-based search. Tools like Claude Code analyze dependency graphs to automatically construct optimal context, and manually adding a list of key files can further enhance accuracy.

← All posts