The context sandwich wraps your task with who you are and what good looks like. Learn this simple prompting framework for ChatGPT Work and Claude agents.
Why Your AI Prompts Keep Falling Short #
You type a request into ChatGPT or Claude, get back something that’s almost right but not quite, and spend the next ten minutes tweaking it. The output is generic. The tone is off. It didn’t account for the thing you thought was obvious.
The problem usually isn’t the model. It’s the prompt.
Most people write prompts like search queries — a few words describing what they want. But AI models don’t work like search engines. They work better when they understand the full picture: who’s asking, what they’re trying to accomplish, and what a good answer actually looks like.
That’s where the context sandwich comes in. It’s a simple, repeatable prompting framework that wraps your task in the information the model needs to do it well. Once you understand it, writing better prompts becomes almost automatic.
What Is the Context Sandwich? #
The context sandwich is a three-part prompt structure. Think of it as:
Top slice— Who you are and why you’re asking** Filling**— The actual task or request** Bottom slice**— What good output looks like
The name comes from the idea that your task (the filling) is sandwiched between two layers of context that give it meaning. Without the bread, the filling falls apart.
Here’s a simple example. Instead of:
“Write a follow-up email to a potential client.”
You’d write:
“I’m a freelance UX designer who just had a 30-minute discovery call with a small SaaS startup. They seemed interested but said they needed to check with their co-founder before moving forward.
Write a follow-up email that keeps the conversation warm without being pushy.The tone should be professional but conversational — not salesy. Keep it under 150 words.”
Remy is new. The platform isn't. #
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
The task is the same. The output is completely different.
Why This Works: How AI Models Actually Process Prompts #
To understand why the context sandwich works, it helps to understand what language models are actually doing when they generate a response.
AI models predict what text should come next based on everything they’ve been given. The more relevant context they have, the better their predictions. A vague prompt produces vague predictions. A rich prompt produces a focused response.
When you give an AI model your role, your goal, and your constraints, you’re essentially narrowing the space of possible responses from millions of plausible answers down to a much smaller set of actually useful ones.
The Role of the “Top Slice”
The top slice — your background context — tells the model what world to operate in. “I’m a pediatric nurse” produces completely different medical writing than “I’m a health blogger” or “I’m a pharma sales rep.” Even if the task is identical, the framing changes everything.
You don’t need to write a biography. A sentence or two is usually enough:
-
Your role or profession
-
The project or situation you’re working in
-
Any relevant constraints (audience, platform, tone)
The Role of the “Bottom Slice”
The bottom slice is about output expectations. This is where most prompts stop short. People ask for something but don’t describe what “good” looks like.
The bottom slice might include:
- Format (bullet list, email, table, numbered steps)
- Length (under 200 words, one paragraph, three options)
- Tone (formal, casual, technical, friendly)
-
What to avoid (no jargon, no fluff, don’t repeat the question)
-
An example of a good output (very powerful when included) The bottom slice keeps the model from going on autopilot. Without it, you get whatever the training data considered a reasonable default — which may have nothing to do with what you actually need.
How to Build a Context Sandwich: Step by Step #
Step 1: Write Your Raw Task First
Start with what you actually want. Don’t overthink it yet.
“Summarize this customer feedback into key themes.”
That’s your filling. Now build around it.
Step 2: Add the Top Slice
Ask yourself: What does the model need to know about me or my situation to do this well?
“I run customer success at a B2B software company. We just finished a quarterly survey with 80 responses, and I need to present findings to the exec team.”
Step 3: Add the Bottom Slice
Ask yourself: What does a great response look like? What should it not do?
“Give me 4–6 bullet points, each with a theme name and one supporting quote from the feedback. Avoid generic themes like ‘communication’ — be specific to what the customers actually said. Skip any themes mentioned by fewer than 5 respondents.”
Step 4: Put It Together
“I run customer success at a B2B software company. We just finished a quarterly survey with 80 responses, and I need to present findings to the exec team.
Summarize this customer feedback into key themes.
Give me 4–6 bullet points, each with a theme name and one supporting quote. Avoid generic themes like ‘communication’ — be specific to what customers actually said. Skip any themes mentioned by fewer than 5 respondents.”
Remy doesn't build the plumbing. It inherits it. #
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
That’s a context sandwich. It takes about 90 seconds longer to write than a raw prompt, and it consistently produces better results.
Context Sandwich Examples Across Different Use Cases #
Content and Copywriting
Without context sandwich:
“Write a LinkedIn post about our new product launch.”
With context sandwich:
“I’m the co-founder of a startup that makes project management software for architecture firms. We’re launching a new feature that auto-generates project timelines from a brief. Our LinkedIn audience is mostly senior architects and firm owners, not tech people.
Write a LinkedIn post announcing this launch.
Make it feel like a founder talking to peers, not a marketing announcement. Lead with the problem the feature solves, not the feature itself. Keep it under 200 words. No emojis.”
Data Analysis
Without context sandwich:
“Analyze this sales data and tell me what’s happening.”
With context sandwich:
“I’m a sales operations manager at a mid-market SaaS company. Q3 just closed and I’m looking at regional performance data before a leadership review tomorrow.
Analyze this sales data and identify the top 3 performance patterns worth discussing.
Focus on trends that are statistically notable, not just big absolute numbers. Flag anything that changed significantly from Q2. Present findings as a short executive summary — three to four sentences per finding, no charts.”
Technical Documentation
Without context sandwich:
“Write documentation for this API endpoint.”
With context sandwich:
“I’m a developer advocate writing for an audience of backend engineers who are new to our platform but experienced with REST APIs. This is for our public developer docs.
Write documentation for this API endpoint.
Use the same format as Stripe’s API docs: a brief description, then parameters in a table, then a request/response example in JSON. Assume the reader knows what HTTP verbs are but doesn’t know our data model yet.”
Customer-Facing Communication
Without context sandwich:
“Write a response to this customer complaint.”
With context sandwich:
“I work in support at an e-commerce company. This customer ordered a gift for their daughter’s birthday, it arrived three days late, and they’re understandably frustrated. We can offer a 20% discount on their next order or free expedited shipping.
Write a response to this complaint.
Be warm and genuinely apologetic — don’t be defensive or corporate. Acknowledge the specific situation (birthday gift, late arrival). Offer both options and let them choose. End on a positive note. Keep it under 120 words.”
Common Mistakes That Undercut the Sandwich #
Even with the framework, a few patterns consistently produce weak results.
Being vague about audience
“Write this for a general audience” is almost useless. Who is a general audience? What do they know? What do they care about? The more specific you are about who will read the output, the better the model can calibrate vocabulary, depth, and tone.
Describing your process instead of your goal
“I need to write an email because I had a meeting and we talked about the proposal and now I need to follow up.” That’s a narrative. What you need to say is: “I’m following up on a proposal discussion to move the deal forward without coming across as pushy.”
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
State the goal, not the history.
Forgetting the bottom slice entirely
The top slice gives the model a starting point. The bottom slice tells it when to stop. Without output instructions, models tend to over-explain, pad responses with caveats, or default to whatever format they think is appropriate — which often isn’t what you needed.
Making the sandwich too long
More context isn’t always better. If your prompt is four paragraphs of background before you even get to the task, you’re overwhelming the model and potentially diluting its focus. Aim for the minimum context that meaningfully changes the output.
How the Context Sandwich Fits Into Prompt Engineering More Broadly #
The context sandwich isn’t the only prompting technique worth knowing, but it’s one of the most broadly applicable. It works across models, tasks, and experience levels because it addresses the most common root cause of bad outputs: insufficient framing.
A few other techniques that pair well with it:
Chain-of-thought prompting — Ask the model to reason through a problem step by step before giving a final answer. This reduces errors on multi-step tasks. You can add it to your bottom slice: “Think through this step by step before writing the final answer.”
Few-shot examples — Include one or two examples of the output you want directly in your prompt. This is the most powerful thing you can add to a bottom slice. Instead of describing what good looks like, show it.
Role prompting — Ask the model to take on a specific persona or expertise: “You are a senior copywriter who specializes in B2B SaaS.” This works similarly to the top slice’s “who you are” framing, but applied to the model itself.
Constraint stacking — List specific things the output should and shouldn’t do. “Use bullet points, not paragraphs. Avoid passive voice. Don’t use the word ‘leverage.’”
Research from OpenAI on prompting best practices confirms that clear instruction, relevant context, and defined output format are the three variables that most reliably improve model performance — which maps directly to the three parts of the context sandwich.
Using the Context Sandwich in AI Agents and Workflows #
The context sandwich isn’t just for one-off chat prompts. It’s actually more important when you’re building AI agents or automated workflows — because there’s no human in the loop to catch a vague prompt and ask for clarification.
When you’re wiring up an AI step in a workflow, the prompt is effectively permanent. It runs the same way every time. If the top slice is missing, every run gets generic output. If the bottom slice is missing, the format varies unpredictably from one run to the next.
System Prompts Are a Full Context Sandwich
Most AI agent frameworks separate the prompt into a system prompt and a user message. The system prompt is where you put the top and bottom slices — who the agent is, what it’s supposed to do, and what good output looks like. The user message is where the task or data comes in.
Other agents start typing. Remy starts asking. #
Scoping, trade-offs, edge cases — the real work. Before a line of code.
A well-written system prompt for a customer support agent might look like:
“You are a support agent for a project management SaaS company. You respond to customer questions about billing, account management, and feature usage. Your tone is helpful and direct — not formal, not overly casual.
Always acknowledge the customer’s question before answering. If you don’t know the answer, say so clearly and suggest they contact
[support@company.com]. Never speculate about roadmap items or make promises about future features. Keep responses under 150 words unless the question is genuinely complex.”
That’s a context sandwich at the system level. Every message the agent processes runs through that framing.
How MindStudio Makes This Easier at Scale #
If you’re building AI workflows or agents, applying the context sandwich manually to every prompt gets tedious fast. MindStudio’s visual workflow builder lets you encode your prompting structure once and reuse it across every run. When you build an AI step in MindStudio, you write your system prompt once — with the top and bottom slices baked in — and then map dynamic variables into the task portion. So the structure stays consistent, but the content adapts to each input.
For example, a customer feedback summarization agent might have:
Top slice(system prompt): “You are analyzing customer feedback for a B2B SaaS product. The audience for your summaries is the exec team, not the customer success team.”Task(dynamic):{{feedback_text}}
Bottom slice(system prompt continued): “Return exactly 5 bullet points. Each bullet should name a theme and include a direct quote. Skip themes mentioned fewer than 3 times.”
Every time a new batch of feedback flows through the workflow, the same structured prompt runs — no manual copy-pasting, no inconsistent framing.
MindStudio gives you access to 200+ AI models (including Claude, GPT-4o, and Gemini) without needing separate API keys, and connects to over 1,000 integrations — so you can pull feedback from Airtable, run it through a context-sandwiched prompt, and push the summary directly to Slack or Notion without writing any code. You can try MindStudio free at mindstudio.ai.
If you’re already thinking about how to systematize your prompting, this kind of structured agent workflow is the natural next step after mastering the sandwich itself. You can explore how to build AI workflows in MindStudio to see how prompt structure fits into larger automation pipelines.
Frequently Asked Questions #
What is the context sandwich in prompt engineering?
The context sandwich is a prompting structure that surrounds your task with two layers of context. The top layer establishes who you are, your role, or your situation. The middle is the actual request. The bottom layer defines what a good response looks like — format, tone, length, and constraints. Together, these three parts give the AI model enough information to produce a focused, useful output rather than a generic one.
Does the context sandwich work with all AI models?
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
Yes. The underlying logic applies across models — ChatGPT, Claude, Gemini, and others. All of these models benefit from clear role framing and defined output expectations. The specific phrasing may need slight adjustments depending on the model, but the structure itself is universally effective.
How long should a context sandwich prompt be?
Most effective context sandwiches are between 50 and 200 words total. The goal is the minimum context that meaningfully changes the output — not maximum detail. If your background context runs longer than your actual task, trim it. More words don’t always mean better results.
Is the context sandwich the same as few-shot prompting?
No, though they work well together. Few-shot prompting means including one or more examples of the output you want directly in the prompt. The context sandwich is about framing (who you are, what you need, what good looks like). You can use examples as part of your bottom slice, which makes the combination particularly effective.
When should I use the context sandwich?
Use it whenever you’re writing a prompt that will be used more than once, whenever the default output isn’t good enough, or whenever the task has specific format or tone requirements. It’s especially valuable in AI agents and automated workflows where prompts run without human review.
Can the context sandwich be used in AI agent system prompts?
Yes — and this is one of the most practical applications. A system prompt is effectively a permanent top and bottom slice. You establish the agent’s role and behavior in the system prompt, then pass the task or data as the user message. This gives every run of the agent consistent framing without rewriting the prompt each time.
Key Takeaways #
- The context sandwich wraps your task with who you are (top slice) and what good output looks like (bottom slice) — giving AI models the framing they need to produce useful results.
- Most prompt failures come from missing context, not missing capability. The sandwich addresses the most common root cause of generic or off-target outputs.
- The bottom slice — defining format, tone, and constraints — is the part most people skip, and often the most impactful addition.
- The technique scales naturally into AI agents and workflows, where system prompts serve as a permanent context layer around every task.
- You don’t need a long prompt to make it work. Aim for minimum effective context — enough to meaningfully change the output, nothing more.
If you want to move beyond one-off prompts and build agents that apply the context sandwich consistently at scale, MindStudio is worth exploring. The no-code builder makes it straightforward to encode your prompting structure once and run it reliably across any workflow — without managing API keys or infrastructure yourself.