---
title: "Context Engineering — How Is It Different from Prompt Engineering?"
url: https://blog.tyrano.dev/en/context-engineering-how-is-it-different-from-prompt-engineering
lang: en
site: Tech AI News - 테카이
category: "AI Glossary"
tags: ["ai terminology","context engineering","context engineering","prompt engineering","ai agents","llm"]
published: 2026-11-18T06:00:56.814Z
updated: 2026-11-19T12:17:32.473Z
sources:
  - https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
  - https://simonwillison.net/2025/Jun/27/context-engineering/
  - https://research.trychroma.com/context-rot
  - https://atlan.com/know/context-engineering-vs-prompt-engineering/
  - https://tianpan.co/blog/2026-02-28-four-strategies-agent-context-engineering
---

# Context Engineering — How Is It Different from Prompt Engineering?

> If you think of context engineering as just a fancy name for "writing better prompts," you'll never get to the bottom of why an agent running for a long stretch suddenly produces a bizarre answer. The problem is often not the instruction sentence itself, but the entire set of tokens the model is looking at in that moment.

---

## Background / Why This Term, Why Now

In June 2025, developer Simon Willison wrote on his blog that "context engineering is emerging as a better term than prompt engineering," and the phrase began to spread widely from there. He explained that the term more accurately captures the essence of the work: "providing all the context necessary for the model to plausibly solve the task." The discussion grew further when Andrej Karpathy voiced agreement with the post and Shopify CEO Tobi Lütke began using the same term.

This trend was further consolidated that September with Anthropic's official engineering blog post, "Effective context engineering for AI agents." Anthropic defined context engineering as "curating and maintaining the optimal set of tokens" to give the model during LLM inference, explicitly stating that its scope differs from simply polishing prompt wording.

The reason the term emerged at this particular moment is a shift in how work gets done. In single-turn question-and-answer tasks, the instruction text (the prompt) determined the outcome, but in agentic tasks that span multiple steps — calling tools, retrieving information, referencing results from earlier steps — what gets "loaded in" in front of the model at each step matters more. Miss this shift, and when an agent keeps making mistakes in a long task loop, you'll keep looking for the cause in the prompt wording alone.

## Key Data & Current State

| Axis of Comparison | Prompt Engineering | Context Engineering |
|---|---|---|
| **Scope covered** | A single instruction statement | System prompts, tool definitions, retrieved results, conversation history, memory as a whole |
| **Core question** | How should I instruct it so the model understands well | What's the minimal set of high-signal information the model needs to see at this step |
| **Representative techniques** | Role assignment, few-shot examples, structuring instructions | Just-in-time retrieval, compaction, structured notes, sub-agent isolation |
| **Relationship** | A component of context engineering | The broader concept that encompasses prompt engineering |

(Based on Simon Willison, June 2025; Anthropic, "Effective context engineering for AI agents," Sept. 2025)

- **Context Rot:** A July 2025 study by content-retrieval startup Chroma ("Context Rot: How Increasing Input Tokens Impacts LLM Performance") measured 18 current models, including GPT-4.1, Claude 4, Gemini 2.5, and Qwen 3, and found that performance grows progressively more unstable as input tokens increase. Performance degradation showed up faster when the semantic similarity between the target information and the question was lower, and when there were more distractors.
- **Survey data (for reference):** Data platform vendor DataHub's 2026 "State of Context Management Report" found that 82% of IT and data leaders said "prompt engineering alone is no longer enough." That said, since this is a vendor-sponsored survey, it's more appropriate to treat it as a directional read on industry perception rather than take the number itself at face value.

> Analysis: Both figures point to the same thing. Filling the context with "more" is not the solution — as the Context Rot research shows, it can even backfire. What matters is the design question of what information to put in, and when to take it back out.

## In-Depth Analysis

### 1) What Exactly Is Context Engineering

Unpacking Anthropic's definition, context engineering starts from the premise that a model's "attention budget" is limited. Simply loading in more tokens doesn't improve performance, so the core task is finding and inserting the "smallest number of high-signal tokens" that can plausibly produce the desired result. This covers everything from adjusting the tone and length of the system prompt, to designing which tools to give an agent, to how external documents are retrieved, to deciding what to keep and what to discard as a conversation grows long.

Willison split this a little differently. He proposed that prompt engineering can be divided into "context engineering (selecting and preparing the context a task needs)" and "prompt programming (writing clear instructions)." The wording differs, but the conclusion is the same: writing good instructions is just one piece of the larger task — deciding what to place in front of the model.

Concepts already covered on this blog are, in the end, components of this larger concept too. RAG (Retrieval-Augmented Generation), which pulls in external knowledge through retrieval and inserts it into the context; MCP (Model Context Protocol), which standardizes how a model accesses external tools and data; and memory design, which retains information beyond a single conversation — each of these is a technique for handling "what to put into the context," and context engineering is the broader framework that coordinates these techniques from the standpoint of the task as a whole.

### 2) Common Misunderstandings — Why People Read It That Way

The most common misunderstanding is the exaggeration of calling "changing a single line of a prompt" context engineering. Adding one sentence to a system prompt doesn't make that context engineering. The two terms look like they overlap because, in practice, editing a system prompt touches both — but the difference lies not in "how that sentence is worded" (prompt engineering), but in whether you designed what, why, and when should go into that slot in the first place (context engineering).

Another misunderstanding is the expectation that "this problem will go away once context windows get bigger." As Chroma's Context Rot research shows, model quality starts degrading before the context window even fills up. Making the window bigger doesn't replace context engineering — if anything, it just means there are more tokens to manage.

### 3) The Actual Test for Telling the Two Apart

The question that separates "is this change context engineering, or just a prompt tweak" narrows down to one thing: did what gets placed in front of the model itself change, or did only the wording of what was already there change? For example, polishing a tool description to be friendlier is prompt engineering, but reducing or splitting the set of tools given to an agent in the first place, or handing it just a file path to pull in on demand instead of preloading an entire document (just-in-time retrieval), is context engineering.

Developer Tian Pan laid out four context-management strategies for agents performing long-running tasks: writing to external storage (write), selectively retrieving on demand (select), compressing what's in the window (compress), and isolating work into a separate agent process (isolate). Apply any one of these four and you've done context engineering; simply editing an instruction sentence falls outside that category.

### 4) When It Matters and When It Doesn't

For simple tasks that produce one answer to one question — one-off tasks like summarizing a short document or translating text — prompt engineering alone is often enough. Willison himself drew a line here, noting that not every task needs context engineering.

Conversely, for long-running task loops like coding agents — which read files, call tools, and decide their next action by referencing results from earlier steps across multiple turns — context engineering is essential. In these tasks, failures don't accumulate slowly: some reports note that the failure rate doesn't rise gently as task duration increases, but instead has a point where it bends sharply upward. That means no amount of polishing the instructions will fix the problem unless you clean up the unnecessary context that has piled up along the way.

## In Practice — 5 Principles for Reading Context Engineering Correctly

1. **Approach it as "just enough," not "more."** Working from the premise that the model's attention budget is limited, look for what to remove before adding more.
2. **Keep tools and system prompts to a minimal set.** The longer the tool list and the more its descriptions overlap, the more confused the model gets about which tool to use. A small number of clear tools, plus a handful of varied examples instead of a long list of exceptions, works better.
3. **Favor structures that retrieve on demand.** Rather than preloading an entire document or codebase, design the system to hand over just a file path or reference and retrieve it at the step where it's actually needed — this keeps unnecessary tokens from piling up.
4. **Compact when a conversation or task runs long.** Build a compaction step into the workflow that turns progress so far into a high-signal summary and reloads that — this can delay the point at which performance drops before the window fills up.
5. **Split the work when it gets complex.** Instead of trying to cram one long task into a single context, isolate independent subtasks into separate agents or sessions, each holding only the context it needs.
