Distinguish context engineering from prompt engineering in one practitioner's working definition

**Prompt engineering** is the craft of writing the instruction itself. It is about phrasing, examples, role priming, output formatting hints, the literal words you send to the model to get good behavior. When ChatGPT first popularized the term in 2022-2023, that was essentially the whole game: write a better prompt, get a better answer. **Context engineering** is broader. It is the system-design discipline of deciding what *everything* that reaches the model's context window on a given turn should be. The instruction is one ingredient. The other ingredients include: the system prompt with persona and rules, retrieved chunks pulled from a vector store or knowledge base, tool outputs from earlier steps of the same trajectory, memory facts pulled from a memory store, conversation history (possibly summarized), the agent's scratchpad, and the output schema the response has to fit. A helpful analogy is cooking. Prompt engineering writes the recipe, the instructions for what to do with the ingredients. Context engineering builds the kitchen, stocks the pantry, and decides which ingredients hit the counter for this particular dish. A great recipe with a missing ingredient produces nothing useful; a fully stocked pantry with no recipe produces chaos. The two disciplines complement each other, but they have different scope. The distinction matters because in a modern production LLM application, the instruction is a small fraction of what reaches the model. The rest is composed at runtime: retrieval brings in 2K-10K tokens per turn, tool outputs add more, memory and history layer on top. Tuning the instruction in isolation cannot fix problems that live in the composition.

Prompt engineering is the craft of the instruction string itself: phrasing, in-context examples, role priming, output format hints. It treats the prompt as a piece of writing to optimize and the model as a fixed evaluator of that writing. Context engineering is the system-design discipline of choosing, structuring, and budgeting *everything* that reaches the model's context window on a given turn. The instruction is one element among many. The others are: - **System prompt**: persona, hard rules, output contract, tool schemas, typically stable across calls and cacheable. - **Retrieval**: chunks fetched from a vector store, knowledge base, or live API, scoped to the current turn. - **Tool outputs**: results from tool calls in earlier steps of the same trajectory. - **Memory**: durable facts about the user or domain pulled from a memory store. - **Conversation history**: prior turns, often summarized as the session grows. - **Scratchpad**: the agent's intermediate reasoning notes, if any. - **Output structure hints**: schema fragments, JSON shape, format rules. Each of these has provenance, a lifetime, a typical size, and a placement rule. Each one competes for the same scarce resource: the effective token budget within which the model still performs well, which is much smaller than the advertised window because of the lost-in-the-middle effect. The practical distinction between the two disciplines is which questions they answer. Prompt engineering answers: how do I phrase this instruction so the model interprets it correctly? Context engineering answers: which retrieval chunks did we pull, how many tool results are sitting in context, where in the prompt do they live, what should we evict, what should we cache? A useful analogy: prompt engineering writes the recipe. Context engineering builds the kitchen, stocks the pantry, decides which ingredients come out of the pantry for this dish, and figures out what to put back when the counter is full.