From Prompt Engineering to Context Engineering

If you've been using AI coding assistants and noticed your carefully crafted prompts still produce inconsistent results, you're experiencing the limits of prompt engineering. The industry has quietly shifted toward something more fundamental: context engineering.

This guide explains what changed, why it matters, and how to think about AI interactions differently.

The Shift: What Changed in 2025

For years, the advice was simple: write better prompts. Be specific. Use examples. Structure your requests clearly. This worked—until it didn't.

The breaking point came with agentic AI. When AI systems started executing multi-step tasks autonomously, prompt quality stopped being the bottleneck. The new constraint? What information the model has access to at each step.

Andrej Karpathy captured this shift with a useful analogy: if the LLM is a CPU, then the context window is RAM. Prompt engineering is like optimizing a single instruction. Context engineering is like designing how an operating system manages memory.

"Context engineering is the delicate art and science of filling the context window with just the right information for the next step." — Andrej Karpathy

Prompt Engineering vs Context Engineering

Prompt engineering asks: "How do I phrase this request?"

Context engineering asks: "What information does the model need to succeed—and how do I get it there?"

The Four Pillars of Context

Context engineering manages four interconnected elements:

1. Instructions

Your system prompts, task definitions, and rules. But unlike prompt engineering, context engineering recognizes that instructions compete for space with everything else. The goal isn't comprehensive instructions—it's sufficient instructions that leave room for the information that matters.

Key insight: Capable models need fewer instructions. Start minimal, add only when you observe failures.

2. Memory

Two types matter:

• Short-term (session): What happened earlier in this conversation. Includes your messages, AI responses, and tool outputs.
• Long-term (cross-session): Persistent knowledge about your project, preferences, and past decisions.

The challenge: memory accumulates. A 200K token window fills faster than you'd expect when an agent runs dozens of tool calls.

3. Knowledge

External information retrieved during execution: documentation, code files, search results, database records. This is where RAG (Retrieval-Augmented Generation) fits in.

Key insight: Just-in-time retrieval beats pre-loading. Don't stuff context upfront—let the model fetch what it needs when it needs it.

4. Tools

Every tool the model can call has a description that consumes tokens. Tool outputs—especially code, logs, or API responses—can be massive.

Key insight: Tool descriptions that overlap confuse models about which tool to use. Keep tools distinct and self-contained.

Core Techniques

Context engineering uses four primary techniques to manage these pillars:

Write: Externalize Context

When information might be needed later but doesn't need to be in context now, write it somewhere external.

• Scratchpads for intermediate reasoning
• Notes files for architectural decisions
• Checkpoints for long-running tasks

This is why CLAUDE.md files, .cursorrules, and similar project context files exist—they externalize persistent context so it doesn't bloat every conversation.

Select: Retrieve Strategically

Not everything belongs in context. Select what's relevant for the current step.

• Use embeddings to query memory
• Apply RAG for knowledge retrieval
• Fetch tool descriptions on-demand instead of loading all tools upfront

Compress: Reduce Token Load

When context grows too large:

• Summarize: Condense earlier conversation turns into key points
• Trim: Drop older messages that are no longer relevant
• Compact: Remove redundant tool outputs, keep only results

Isolate: Partition Context

For complex tasks, split context across boundaries:

• Sub-agents: Specialized agents handle focused subtasks, return summaries
• Sandboxes: Separate environments for different concerns
• State schemas: Structured fields that organize information by type

Context Engineering in Practice

Here's how these concepts apply to AI coding tools:

Project Context Files

Most AI coding tools support persistent context files (CLAUDE.md, .cursorrules, etc.). These are context engineering in action—they provide information that every interaction needs without you repeating it.

Best practices:

• Keep root files to 100-200 lines maximum
• Use subdirectory-specific files for local rules
• Prefer pointers over code snippets (snippets go stale)
• Don't duplicate what linters already enforce

Session Management

Context accumulates during a session. Long sessions mean the model is working with increasingly stale and noisy context.

Best practices:

• Clear context between distinct tasks
• Start fresh conversations for unrelated work
• Summarize complex discussions before continuing

Structured Prompts

When you do write instructions, structure matters. Context engineering borrows from systems design:

• Organize into distinct sections (constraints, examples, success criteria)
• Use consistent formatting (XML tags, Markdown headers)
• Put critical information early—models attend more to the beginning

Tool Design

If you're building custom tools or MCP servers:

• Write descriptions that don't overlap with other tools
• Return minimal, token-efficient responses
• Include only information the model needs to proceed

The Minimum Viable Context Principle

The core philosophy of context engineering is counterintuitive: less is more.

Every token in context competes for the model's attention. Irrelevant information doesn't just waste space—it actively degrades performance. The goal isn't maximum context, it's optimal context.

Ask: "What is the smallest high-signal context that maximizes the likelihood of the desired outcome?"

This means:

• Don't pre-load everything "just in case"
• Prune aggressively as context grows
• Trust the model to request information it needs
• Measure success by output quality, not context size

Common Pitfalls

Stuffing context with edge cases: Adding exhaustive rules for rare scenarios dilutes attention on common cases.

Ignoring context limits in extended workflows: Agents that run 100+ steps will hit context limits. Plan for compaction.

Overlapping tool descriptions: When tools sound similar, models struggle to pick the right one.

Hardcoding brittle logic: Complex conditional logic in prompts breaks easily. Let the model reason instead.

Never clearing context: Accumulated history from unrelated tasks creates noise.

Key Takeaways

1. Context engineering is systems thinking for AI interactions, not just better wording

2. Four pillars: Instructions, Memory, Knowledge, and Tools—all compete for the same limited window

3. Four techniques: Write (externalize), Select (retrieve), Compress (reduce), Isolate (partition)

4. Minimum viable context: The goal is smallest high-signal context, not maximum information

5. Project context files are the primary context engineering tool for AI coding assistants

6. Session hygiene matters: Clear context between tasks, start fresh for unrelated work

The shift from prompt engineering to context engineering reflects a deeper truth: as AI systems become more capable and autonomous, the bottleneck moves from "how do I ask" to "what does it know." Master this, and your AI tools become dramatically more effective.

Additional Resources

• Anthropic: Effective Context Engineering for AI Agents
• LangChain: Context Engineering for Agents
• Gartner: Context Engineering

Related content

• 📘 Prompt Engineering for Claude: Best Practices — Where it all started: the foundational discipline context engineering builds upon
• 📘 Claude Context Window: Complete Guide — The technical resource context engineering seeks to optimize
• 📘 Claude Skills: Customize Workflows — A practical implementation of context engineering with Skills
• 📘 Agentic Engineering: The Complete Framework — The evolution that came next: from context to agentic engineering