If you watched my breakdown of Loop Engineering, you already know the old way of prompting AI is changing fast. But there's a deeper question we didn't answer: what determines whether each iteration of a loop produces good output or garbage?

The answer is context. Not the prompt. The context.

Same Prompt. Different Results. Why?

Every developer has experienced this. You type "write me an auth module" into Claude or ChatGPT. You get back generic JWT boilerplate. Wrong framework. Wrong patterns. You rewrite 80% of it.

Now imagine the same prompt — exact same words — but this time, the AI has your CLAUDE.md loaded with your tech stack, it's retrieved your team's auth patterns, it knows your error-handling conventions, and it can see your existing code structure.

✕ No Context "Write me an auth module" AI outputs generic JWT code. Wrong framework. Wrong patterns. You rewrite 80% of it. ✓ Rich Context "Write me an auth module" + CLAUDE.md with stack info + Retrieved auth patterns + Team's error-handling rules + Existing code conventions AI outputs production-ready code. Right patterns. Ships.

Same prompt. Completely different output. The difference isn't the prompt — the prompt was identical. The difference is the context.

We spent two years optimizing the words we type into AI. But the words were never the bottleneck. The information environment around those words — that's what determines output quality.

What Is Context Engineering?

Anthropic defines it like this: building with language models is becoming less about finding the right words for your prompts, and more about answering the question — what configuration of context is most likely to generate the model's desired behavior?

CONTEXT Prompt Memory Tools Retrieved Data Conv. History System Prompt Current State

The prompt — the thing we've been obsessing over — is just one small piece of the total context. Context includes your system prompt, conversation history, retrieved data, tools the model can use, memory from past sessions, and the current state of whatever task the AI is working on.

Prompt engineering optimizes that little circle in the center. Context engineering optimizes everything around it.

Prompt Engineering vs Context Engineering

Prompt EngineeringContext Engineering
Crafts the instructionDesigns the information environment
Optimizes one interactionOptimizes all interactions
Manual, per-sessionSystematic, persistent
"How do I word this?""What should the model see?"
Individual skillTeam-level infrastructure
Trial and errorStructured, measurable

The question shifts from "how do I word this" to "what should the model see." That's a fundamentally different engineering problem. And crucially — prompt engineering is an individual skill. Context engineering is team-level infrastructure. When one person writes a great CLAUDE.md, every developer on the team benefits. It compounds.

The 4 Pillars of Context Engineering

There are four operations you perform on information before it reaches the model.

01 Write Structure raw info into reasoned text 02 Select Retrieve only what's relevant. Not keyword dump. 03 Compress Summarize and distill. Less beats more. 04 Isolate Each agent sees only what it needs.
  • Write — Take raw information — your codebase, docs, conventions — and structure it into text the model can reason over. This is CLAUDE.md, system prompts, and rule files.
  • Select — Retrieve only what's relevant using semantic search. Not keyword dump. A JetBrains study showed that just hiding irrelevant information improved accuracy by 2.6% while cutting costs by 52%.
  • Compress — Summarize and distill. More context often makes AI worse, not better. The needle-in-a-haystack problem is real.
  • Isolate — Prevent cross-contamination between tasks. Each agent should see only what it needs for its specific job.

CLAUDE.md: Context in Practice

The single most important context engineering artifact you can create today is a CLAUDE.md file.

# Project: MyApp

## Stack
- React 19 + TypeScript
- Tailwind CSS, no styled-components

## Rules
- All errors use AppError class
- Tests: Vitest, not Jest
- Always run lint before commit

## Patterns
- Use server actions, not API routes

Every time Claude Code opens your project, it reads this file first. Before you type anything. Before you write any prompt. The context is already loaded.

What this gives the AI:

  • Knows your stack — won't suggest Next.js when you're using Remix
  • Follows your rules — every error handling block uses AppError
  • Uses your patterns — consistently, across every session
  • Persists across sessions — close your terminal, come back tomorrow, context is still there
  • Shared with your team — anyone who clones the repo gets the same context

Tools Are Context

Here's an insight from Anthropic that's genuinely underappreciated — tools ARE context. When you give an AI agent tools, those tool definitions go into the context window. Poorly designed tools pollute the context just like bad prompts do.

Anthropic's blog post explicitly calls out bloated tool sets as the #1 failure mode they see in production.

✕ Bloated Tool Set get_user_data() fetch_user_info() retrieve_user_profile() load_user_details() ✓ Lean Tool Set get_user(id) Single source of truth search_records(query) Clear, scoped update_record(id, data) Explicit write

The rule is simple: if a human engineer can't tell which tool to use, neither can the model. Fewer, sharper, more distinct tools with clear descriptions.

Less Context Beats More Context

More context makes AI worse, not better. This isn't opinion — it's backed by research.

+2.6% Accuracy Just by hiding irrelevant info JetBrains Study -52% Cost Less context = cheaper + better JetBrains Study -86% Drift Structured vs. static context Stanford ACE Paper

The lesson is clear. Context engineering isn't about giving the model more. It's about giving the model less — but the right less.

The Context Stack

Think of context as a three-layer stack, from most stable to most volatile.

Persistent Layer Always present. Read every session. CLAUDE.md · System prompts · Team rules · .cursorrules Session Layer Retrieved at runtime. Changes per task. RAG results · Conv. history · File contents · Git diff Transient Layer Temporary. One operation. Tool outputs · API responses · Test results ▲ More volatile ▼ More stable

Good context engineering means getting the persistent layer right first — because it's the foundation everything else builds on. If your CLAUDE.md is wrong, no amount of clever RAG or tool design will fix it. Start from the bottom. Get the foundation right. Then work your way up.

How to Start Context Engineering Today

  1. Write your CLAUDE.md — Run /init in Claude Code to generate a starter. Then make it yours. Add your team's conventions, error-handling patterns, and architectural decisions.
  2. Trim your tool set — Audit every tool definition. Remove duplicates. Make names self-explanatory. Write clear descriptions.
  3. Scope your context — Don't dump entire codebases. Use @file references. Give the model only what it needs for this task.
  4. Measure and iterate — Track output quality before and after context changes. Context engineering is measurable, not guesswork.

Final Thoughts

The teams getting the best results from AI in 2026 aren't the ones writing the cleverest prompts. They're the ones engineering the best context.

A great CLAUDE.md file. Clean, lean tool definitions. Scoped, relevant retrieval. Structured context stacks. These are the things that separate AI code that ships from AI code you rewrite.

Better context, not better prompts.

This is the companion post to Loop Engineering Explained — loops are HOW the AI runs, context is WHAT it sees while running. Watch both for the full picture.