Identify every activity below that is context engineering rather than prompt engineering

Multi-select·Medium·4.0 · 0·~1 min·Asked atJasper Mu Sigma Reliance Jio

Attempt it

The distinction between prompt engineering and context engineering is a question of layer. Both make the model better, but they intervene at different points in the pipeline. **Prompt engineering** changes the literal instruction string. Wording, phrasing, examples embedded in the prompt, role priming, formatting rules, all changes to the text the human-author writes. **Context engineering** changes what arrives at the model around the instruction. Retrieval policy, history compaction, memory write/read rules, tool output routing, output schema enforcement, budget allocation, all changes that happen at composition time, before the prompt is finalized. Walk through the six options: - **0. Tuning rerank top-k from 20 to 5.** This is context. Retrieval is a composition-time decision. The prompt text does not change; what arrives at the model does. - **1. Rewriting the system prompt with numbered rules.** This is prompt engineering. The wording of the instruction is being edited. - **2. Switching from raw history to a rolling summary above 8K.** This is context. The compaction policy decides what arrives. - **3. Adding chain-of-thought examples to the user instruction.** This is prompt engineering. The examples are inside the prompt string. - **4. Routing long tool outputs through a summarizer.** This is context. The tool-output pipeline is composition-side. - **5. Replacing a free-text JSON request with a Pydantic schema.** This is context. The schema-bound path replaces a prose instruction with a separate constraint pathway, that is a composition change, not a wording change. The correct answers are 0, 2, 4, and 5.

**The line between prompt engineering and context engineering is whether the change happens at string-authoring time or at composition time.** Both layers are real and both matter; they just live in different parts of the pipeline. ### What prompt engineering is Prompt engineering is about the literal text of the instruction. It includes: - The system prompt's wording, structure, and formatting. - Few-shot examples embedded in the prompt. - Chain-of-thought scaffolding ('let's think step by step'). - Role priming ('you are an expert legal analyst'). - Output formatting instructions when expressed as prose. A prompt-engineering change is a diff on the string that gets sent to the model. ### What context engineering is Context engineering is about the pipeline that assembles the prompt at composition time. It includes: - Retrieval policy: what chunks to fetch, how many, with what scoring. - Rerank: whether and how to reorder retrieved results. - History compaction: when and how to summarize older turns. - Memory: what to persist, when to read, when to write. - Tool output routing: whether to summarize, truncate, or pass through tool results. - Budget allocation and eviction order under context pressure. - Output schema enforcement: constrained decoding or schema validation with retry as a separate pathway. A context-engineering change is a diff on the assembly logic, not on any specific prompt string. ### Walking the six options **0. Tuning rerank top-k from 20 to 5** is context. Retrieval and rerank are composition-time decisions that determine what evidence arrives at the model. The prompt template that wraps the retrieved content does not change. **1. Rewriting the system prompt with numbered rules** is prompt engineering. The system prompt's text is the canonical prompt-engineering surface. **2. Switching to a rolling summary above 8K** is context.

TL;DR

Context engineering changes what arrives at the model (retrieval knobs, history compaction, tool-output routing, schema enforcement).

Memory aid

Easy to grasp

Think of it like cooking. Prompt engineering is rewriting the recipe: changing the words, adding more example steps, telling the chef in clearer English what to do. Context engineering is changing the kitchen: which ingredients are on the prep table, how much pantry stock the cook can see, whether the spice rack got reorganized, what shape the serving plate is. The recipe in a different kitchen produces a different dish. In this question, anything that changes what is on the prep table (retrieval, history compaction, tool outputs, output schema) is the kitchen. Anything that changes the recipe text itself (system prompt wording, chain-of-thought examples in the instruction) is the recipe.

Key concepts

Context engineering Prompt engineering

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.

Prompt engineering and context engineering get confused for each other because they both feed the same model and both can make it perform better. They are not the same discipline. They operate at different layers of the pipeline, use different tools, have different ownership inside production teams, and fail in different ways. Mixing them up at debug time is one of the more expensive mistakes a team can make.

The operational test is simple. If your change diffs the literal text of the instruction the model reads, you are doing prompt engineering. If your change diffs the assembly logic that decides what arrives at the model, retrieval, history, memory, tool routing, schema enforcement, you are doing context engineering.

This multi-select question is a useful classifier because four of the six options sit cleanly in context, two sit cleanly in prompt, and one (the Pydantic schema) is the textbook subtle case that trips people up. Walking through them clarifies the line and surfaces the production reasons it matters.

The composition versus wording line

Prompt engineering is editing the string. Few-shot examples, role priming, output-formatting instructions in prose, numbered rules, all of these are diffs on the literal text that gets serialized to the model. They are usually owned by domain-specialist authors or by anyone working in a prompt-management surface (LangChain Prompt Hub, Anthropic's system parameter, OpenAI's playground).

Context engineering is editing the pipeline that assembles the prompt at runtime. Retrieval policy decides what chunks land in the context block. The summarizer decides what conversation history looks like above the budget threshold. The tool-output router decides whether a 50k-token API response gets passed through, summarized, or truncated before re-entering context. The schema-enforcement backend decides whether output compliance is enforced by sampler constraints, by validate and retry loops, or by the model alone reading prose. Each of these is a composition-time decision, owned by platform engineers and shaped by infrastructure choices.

The two layers compose. The same prompt template with a different retrieval policy produces different model output. The same retrieval policy with a different system prompt also produces different output. Both axes are real and both matter; the discipline of distinguishing them is what lets a team debug failures correctly and pick the right lever for a fix.

Walking the six options

Why the Pydantic case trips people up

How the layers behave differently in production

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Activity	Layer	Where the change lives
Rewording the system prompt	Prompt	The system prompt string
Adding few-shot examples	Prompt	The user or system prompt string
Tuning rerank top-k	Context	The retrieval pipeline config
History compaction strategy	Context	The conversation-management layer
Tool-output summarization	Context	The tool-result post-processing pipeline
Pydantic schema for output	Context	The constraint-decoding or validation backend

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

Anthropic's prompt engineering guide is explicitly about string-authoring patterns (XML tagging, role priming, output formatting); their context engineering recommendations live in separate docs about prompt caching, tool use, and long-context strategies.
LangChain Prompt Hub stores prompt templates (prompt engineering); LangChain's retrievers, memory, and output parsers are context-engineering primitives.

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

QHow do you tell whether a quality regression is a context problem or a prompt problem?

Replay the failing input with a clean assembled prompt. If the model still fails, it is a prompt problem (the instruction shape is wrong). If the model succeeds, the composition assembled something different in production (a context problem). Logs of the assembled prompt are required for this diagnosis.

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 chain-of-thought examples in the prompt as context engineering because they 'add content.' They live in the instruction string, that is prompt engineering. The line is composition versus wording.

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

The composition vs wording line that defines the two disciplines
Two examples of each that show up in a typical 2026 stack

Primary sources. Browse if you want the original framing.