How to Write Prompts That Work Across AI Models

A good prompt should survive a model switch. If you paste it into GPT-5.6, then Claude, then Gemini, the answers should stay usable, even if the wording shifts. This guide is about how to write prompts that work across AI models: the structure that transfers everywhere, the few conventions that are tied to one vendor, and a repeatable way to harden a prompt so it holds up wherever you run it. It assumes you already write decent single-model prompts and want them to travel.

Why bother? Because the moment you have every major model in one place, you start moving prompts between them constantly: one model for the draft, another for the edit, a third for the sanity check. A prompt that only behaves on the model it was tuned for wastes that flexibility. Research on cross-model transfer is blunt about the cost: prompts engineered for one model often perform substantially worse on another, even when built to be transferable (PromptBridge, PromptPort, 2025 to 2026 preprints). Portability is something you deliberately build into the prompt.

The portable backbone: what transfers everywhere

Strip away the vendor branding and the three major providers converge on the same skeleton. OpenAI, Anthropic, and Google all describe a prompt as some ordering of role, context, task, constraints, output format, and examples. OpenAI's own prompt-engineering guidance, for example, orders a prompt as identity, instructions, examples, and context. These parts carry from model to model. Build on them first.

Role. One sentence that sets the persona focuses behavior and tone on every model. Anthropic notes that even "You are a helpful coding assistant specializing in Python" makes a measurable difference.
Context. The background, audience, and the why behind the task. Explaining the reason ("never use ellipses, because a TTS engine reads this aloud") beats a bare rule on every model Anthropic tested.
Task. The single thing you want done, stated plainly. Gemini's guidance and Anthropic's "golden rule" agree: if a colleague with minimal context would be confused, the model will be too.
Constraints. Length, tone, what to include or avoid. Prefer telling the model what to do over what not to do ("write in flowing prose paragraphs" beats "do not use markdown").
Output format. Bulleted list, table, one paragraph, JSON. Being explicit here is the single biggest lever for getting parseable, comparable answers across models.
Examples. Few-shot examples are one of the most reliable ways to steer format and tone. Anthropic recommends 3 to 5 relevant, diverse examples; Google goes further and says to "always include few-shot examples," keeping their structure identical.
Delimiters. Separate the parts of your prompt clearly. All three providers endorse this: OpenAI says use markdown, XML tags, and section titles; Anthropic recommends XML tags; Gemini 3 accepts XML-style tags or markdown headings.

One more backbone rule for long inputs: when you paste 20k or more tokens of documents, put the long material near the top, above your question and instructions. Anthropic reports this ordering can improve answer quality by up to 30 percent on complex multi-document inputs across its Claude models, and it is a sensible default with other vendors' models too. If you want the underlying mechanics, our explainer on reasoning models covers how the thinking step changes a prompt.

A reusable model-agnostic template

Here is the skeleton I reach for first. It uses XML-style tags as delimiters because they are the lowest common denominator: native to Claude, explicitly accepted by OpenAI and Gemini 3, so one structure reads cleanly on all three. Markdown headings work just as well if you prefer them.

<role>
You are a senior {DOMAIN} editor writing for {AUDIENCE}.
</role>

<context>
{Background the model needs. Why this matters. Any constraints
from the real situation, e.g. "this ships to non-technical users."}
</context>

<task>
{The one thing to do, in plain language.}
</task>

<constraints>
- Length: {e.g. 150 words max}
- Tone: {e.g. plain, concrete}
- Include: {must-haves}
- Prefer doing X over avoiding Y (state positives)
</constraints>

<examples>
{2 to 5 short input/output pairs, identical structure}
</examples>

<output_format>
{Exact shape: a table with columns A/B/C, or strict JSON, or
one paragraph. Be specific enough that a parser would accept it.}
</output_format>

<input>
{The actual material or question goes here, last.}
</input>

Notice what is missing: no "think step by step," no "take a deep breath," no "you are a world-class expert." On the newest models, those are either ignored or counterproductive. More on that below.

Step by step: harden a prompt for any model

Take a prompt that already works on one model and make it portable. Here is the order I run.

Pull it into the backbone. Sort your existing prompt into role, context, task, constraints, examples, output format. If a sentence does not fit one of those slots, question whether it earns its place.
Remove conflicting and redundant lines. OpenAI's GPT-5.1 guide makes this the primary fix: clarify contradictory rules and delete duplicate instructions with small explicit edits. Two rules that quietly disagree confuse different models in different ways.
Strip the personality padding. Phrases like "Take a deep breath" or "You are a world-class expert" are noise to newer models. Cut hype superlatives and over-strong commands; "CRITICAL: you MUST" can over-trigger models that are more responsive to the system prompt.
Pin the output format hard. "Format collapse" is real: a prompt that returns clean JSON on one model can return fenced or prose-wrapped output on another (PromptPort, 2026). Specify the exact shape and, if you can, give one example of it.
Neutralize the delimiters. Swap any model-specific syntax for XML tags or markdown headings, the two formats every provider accepts. Keep tag names descriptive and consistent.
Run it across models and diff the outputs. Paste the same prompt into two or three models and compare. Where the answers diverge in structure (not just wording), the prompt is still leaning on a quirk. Tighten that part and rerun.

Step 6 is where MultiChats earns its keep, with no three-tab, three-login juggling. Use the composer model button (the dialog is titled Select AI Model on web, Select Model on mobile) to run the same prompt through GPT, Claude, and Gemini back to back. Our guide on how to compare AI answers across models walks through this cleanly in one window.

What does NOT transfer (and what to do instead)

A handful of conventions are tied to one vendor, and leaning on them is how a portable prompt breaks. The big ones:

Model-specific quirk	Why it does not travel	Portable move
XML tags as the parsing scheme	Emphasized for Claude; accepted but not required elsewhere	Use them as plain delimiters, not as Claude-only magic
developer vs system message layering	OpenAI-specific; Claude has no developer-message equivalent	Keep all key instructions in one block the model always reads
Prefilled assistant turn	Newer Claude models reject prefill (400 error); no OpenAI/Gemini analog	Steer the opening with an instruction or an example instead
"think step by step" on a reasoning model	Reasoning is internal; the instruction is redundant or harmful	Keep prompts simple; raise reasoning effort instead

That last row is the most common 2026 mistake. Do not force chain-of-thought on a reasoning model. OpenAI states it plainly: since these models reason internally, prompting them to "think step by step" or "explain your reasoning" is unnecessary, and you should keep prompts simple and direct. Anthropic's parallel advice is to prefer general instructions over prescriptive steps, because the model's own reasoning often exceeds a hand-written plan. Manual chain-of-thought survives only as a fallback for when thinking is off.

On non-reasoning models the same instruction can backfire: forcing step-by-step can introduce variability and cause a model to miss easy questions it would otherwise get right (secondary research, 2026, so treat it as "can hurt on some tasks," not a universal law). The cleaner lever sits outside the prompt text entirely: the reasoning effort control, a paid setting in MultiChats with Auto, Low, Medium, High, and Off on models that support it. Dial the thinking up with the toggle rather than baking "think harder" into text that some models will misread.

Two smaller quirks, both version-specific: some OpenAI reasoning models suppress markdown unless you write "Formatting re-enabled," while recent Claude models default to LaTeX for math and need a nudge to plain text. If formatting looks wrong on one model only, this is usually why.

Test it across models in one window

Portability is a claim you have to verify. The fastest test is to run the same prompt through a few models and compare the outputs. In MultiChats, switching the model mid-thread keeps the conversation and its context intact, so you can send your prompt to one model, then pick another from the same composer button and resend without retyping. Premium models show a ✦ Pro badge and need a paid plan; the free models are enough to feel the structural differences. If you are unsure which models to put in the rotation, our guide on how to pick the right AI model covers the tradeoffs, and the ChatGPT vs Claude breakdown shows where two of the big ones part ways.

When you diff the answers, look at structure before prose. Same headings? Same number of items? Same JSON shape? Wording always varies. Structural divergence is the signal that your prompt is still relying on something one model does and another does not.

Portability checklist

Run a prompt down this list before you call it portable.

Role, context, task, constraints, output format, and examples each have a clear slot.
No contradictory or duplicate instructions survive.
Personality padding and "CRITICAL/MUST" hype are gone.
Delimiters are XML tags or markdown headings, nothing vendor-only.
Output format is specified exactly, with an example of the shape.
No "think step by step" aimed at a reasoning model; effort is set with the toggle.
No prefilled assistant turn and no developer-vs-system layering the prompt depends on.
You actually ran it on two or three models and the structure held.

FAQ

Do the same prompts work on ChatGPT, Claude, and Gemini?

Mostly, if you build on the shared backbone (role, context, task, constraints, output format, examples, delimiters). The structure transfers. What does not are the vendor-specific conventions: OpenAI's developer-message layer, Claude prefill, and the assumption that XML tags do something special. A prompt built on the backbone and tested on all three will travel; one tuned to a single model's quirks usually loses ground on transfer benchmarks, often substantially.

Should I tell a reasoning model to think step by step?

No. Reasoning models already think internally, so "think step by step" or "explain your reasoning" is redundant, and OpenAI explicitly advises against it. Anthropic says to prefer general instructions over prescriptive steps for the same reason. If you want deeper thinking, raise the reasoning effort setting instead. Manual step-by-step only makes sense as a fallback when thinking is fully off.

How do I make a prompt portable?

Decouple the logic from any one model's quirks. Sort the prompt into the backbone, remove contradictions and padding, pin the output format with an example, use neutral delimiters, and skip the model-specific tricks. Then run it across two or three models and tighten wherever the answer structure diverges. The blog post on how to write better prompts covers the single-model fundamentals this builds on.

Why does my prompt work on one model but not another?

Usually one of three things. The prompt leans on a vendor-specific feature (prefill, developer messages, a format default like markdown suppression or LaTeX). Or it suffers format collapse, where clean JSON on one model comes back fenced or wrapped on another. Or it forces chain-of-thought on a reasoning model that does not need it. Diff the outputs by structure to find which one is biting, then fix it and rerun.

Wrap up

Portable prompting comes down to a discipline: write to the shared backbone, drop the vendor quirks, and verify by running the same prompt across models rather than trusting that it transferred. Do that and your prompts stop being tied to one model's habits. The fastest place to practice is one app where you can switch between GPT, Claude, Gemini, and more without retyping. Try MultiChats and run your next prompt through three models in a single thread.