Translate the 'recipe vs kitchen' analogy into the prompt vs context engineering distinction

Flashcard·Easy·4.0 · 0·~30s·Asked atDatadog Elastic Sierra

Attempt it

The recipe maps to the literal instruction text: phrasing, examples, few-shots, role priming, formatting rules. The kitchen maps to the surrounding machinery: the retriever and its rerank pipeline, the memory store and its read/write policy, the tool registry and how their outputs thread into context, the conversation summarizer, the output schema, and the budget logic that trims when the window fills. Same recipe in a different kitchen produces a different dish.

Your answer

The recipe and kitchen analogy is a useful way to make the prompt vs context engineering distinction concrete. The **recipe** is the literal text the model reads. It includes: - The system prompt's wording and structure. - Role priming ('you are an expert legal analyst'). - Few-shot examples and chain-of-thought scaffolding. - Output formatting instructions in prose. - The phrasing of the user task. The **kitchen** is the runtime machinery that decides what shows up on each call. It includes: - The retriever: which chunks come back for a given query. - The rerank pipeline: how the retrieved chunks get reordered or filtered. - The memory store and its read/write policy: what gets persisted, what gets recalled. - The tool registry and tool-output routing: which tools are available, how their results land in context. - The conversation summarizer: when and how older turns get compacted. - The output schema: how the response shape is enforced (Pydantic, JSON Schema, or prose). - The budget logic: what gets evicted when the window fills. The two compose. A great recipe in a broken kitchen produces a bad dish. A great kitchen with a vague recipe also produces a bad dish. Most production LLM quality work is kitchen work, even though the recipe is the visible artifact.

**The recipe is the instruction; the kitchen is everything that decides what ingredients land on the prep table.** The analogy maps the two halves of LLM application work onto two visibly different artifacts. ### The recipe, what prompt engineering owns - **System prompt** wording, structure, numbered rules, role priming. - **Few-shot examples** embedded in the prompt. - **Chain-of-thought scaffolding** ('let's think step by step'). - **Output formatting** when expressed in prose. - **Task phrasing** in the user turn. All of this is text that ships verbatim to the model. It is human-readable, version-controllable as a single artifact, fast to iterate on. ### The kitchen, what context engineering owns - **The pantry**: documents and embeddings in the vector store, refreshed by the indexing pipeline. - **The shopping list**: the retrieval query and the retrieval policy (top-k, hybrid search, MMR). - **The sous chef**: the reranker (Cohere Rerank v3, Voyage Rerank-2, BGE-Reranker for self-hosted). - **The pantry organizer**: the memory store (Zep, Mem0, MemGPT/Letta, native session state) and its write/eviction rules. - **The tool drawer**: tool definitions, MCP server registry, and the routing of tool outputs through summarizers before re-entry. - **The leftover-management strategy**: the conversation summarizer that compacts older turns above a budget threshold. - **The plating standard**: the output schema and its enforcement backend (constrained decoding, Pydantic+retry). - **The kitchen capacity rules**: budget allocation, eviction order, output token reservation, prompt caching configuration. All of this is composition logic, code, and infrastructure. It changes how the recipe gets executed on every call. ### Why the kitchen is most of the work in production A team's first few months are usually spent on the recipe. The system prompt gets refined, examples get added, the role gets sharpened.

TL;DR

Recipe is the instruction text (wording, examples, role priming, formatting).

Memory aid

Easy to grasp

Think of a recipe as the page in the cookbook. Mix two cups of flour, beat three eggs, bake at 180. Anyone with the same page should make the same dish, in theory. The kitchen is everything around the page: the fridge, the pantry, the stove, the spice rack, the dishwasher, the prep table, the timer, the trash bin. The same recipe in a kitchen with a broken oven gives you a different dish than the same recipe in a fully stocked professional kitchen. With LLMs, prompt engineering is the recipe page. Context engineering is the kitchen. Two teams can use the same recipe and ship very different products because their kitchens are very different.

Key concepts

Context engineering Prompt engineering LLM frameworks

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Analogies are how teams communicate across disciplines, and the recipe and kitchen framing is one of the cleanest analogies in the LLM application space. The recipe is the visible artifact: the text everyone can read, edit, and reason about. The kitchen is invisible: the infrastructure that decides what gets pulled from the pantry, how it gets prepped, when leftovers get composted, and what the finished plate looks like.

Both halves of the analogy are real engineering work. The mistake teams make is to over-invest in the recipe (because it is visible) and under-invest in the kitchen (because it is hard to see). Most production quality in 2026 comes from kitchen work, retrieval pipelines, memory architecture, tool design, summarization policy, output schema enforcement, even when the team's published prompt is what the world sees.

This question is rated easy because the framing is intuitive. The follow-on questions in interviews are harder because they ask the candidate to actually map each kitchen element to a specific LLM-stack component. Knowing the analogy is the entry point; knowing the mapping is the operational skill.

The recipe in detail

The recipe is the text the model literally reads on each call. It is the prompt-engineering surface, owned by anyone with the prompt file, and includes:

The system prompt: the agent's identity, persona, behavior rules, and safety policies. In 2026 production stacks this is usually a 1,500-4,000-token block that opens every call.
Tool descriptions (the visible part, the schemas live in the kitchen): the prose that explains what each tool does and when to use it. These ride alongside the tool schemas in the system block.
Few-shot examples: demonstration input-output pairs that show the model the shape of the desired response. Used heavily in extraction, classification, and creative tasks.
Chain-of-thought scaffolding: explicit instructions to think before answering, or reasoning templates that structure the thought process.
Role priming: lines like 'you are an expert legal analyst' that frame the model's persona for the call.
Output formatting instructions in prose: 'respond with a bullet list,' 'answer in under 200 words,' 'cite each source.'
The user task: the actual question, request, or instruction in the user turn.

All of this is human-readable text that gets serialized to the model. It is version-controlled as a single artifact (often a markdown file or a YAML prompt template). It is fast to iterate on, change the string, run an eval, see the result. Most teams' first month of LLM application work is dominated by recipe-level iteration.

The kitchen in detail

Why most production quality is kitchen work

When the analogy breaks and how to extend it

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Kitchen element	LLM counterpart	Owned by
Recipe page	System prompt + examples + role priming	Prompt author / domain expert
Pantry	Vector store + indexed corpus	Data engineering
Shopping list	Retrieval query + top-k policy	Platform engineering
Sous chef	Reranker (Cohere, Voyage, BGE)	Platform engineering
Leftover system	Conversation summarizer	Platform engineering
Plating standard	Output schema (Pydantic + structured outputs)	API engineering

Real products, models, and research that use this idea.

Anthropic Claude Code's CLAUDE.md is the recipe; its tool registry, file-reading routing, compaction, and prompt-caching configuration are the kitchen.
GitHub Copilot's system prompt is small and stable; the actual product quality comes from the kitchen: code retrieval across the repo, IDE integration, language-aware context selection.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow does the analogy hold up for agentic systems with sub-agents?

Each sub-agent is a station in the kitchen with its own prep area; the orchestrator is the head chef coordinating across stations. The recipe extends to per-station playbooks. The framing scales as long as you remember the kitchen is the whole shop, not just the main line.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Treating prompt engineering as the whole job because that is the visible artifact. The kitchen is most of where production quality is decided, and it is invisible to the user.

60 second bullets to scan on the way to the call.

Which artifacts belong to the recipe side
At least five distinct kitchen elements and what they map to in the LLM stack

Primary sources. Browse if you want the original framing.