Output Priming: Start the Answer for the Model

TL;DR: Output priming means writing the opening words of the model's own answer yourself, so it continues from there instead of starting fresh. No published paper defines the term. The real mechanism behind it, called prefilling on Anthropic's API, is genuine and well-documented, and Anthropic just stopped supporting it on its newest models.

What is output priming?

Output priming is handing the model the beginning of its own answer and letting it finish the sentence. Instead of asking a question and waiting to see how the reply opens, you write the first few words yourself: a stray { to force JSON, a fixed opening line to skip a throat-clearing preamble, a bracketed tag to hold a role steady across a long role-play.

The plainest version of this works on any model that continues raw text, because that is literally what token-by-token generation does: predict what comes next, given everything that came before, including text you supplied. What varies sharply between vendors is whether their API gives you an official, documented way to submit that partial answer as structured input, guaranteed to be continued rather than restarted or ignored. That documented, guaranteed version is the part worth understanding before you rely on it.

Is there a real paper behind output priming, or is this craft convention?

Craft convention, as far as this search could establish. No academic paper was found that coins or defines "output priming" as this specific technique: writing the start of the model's own turn to steer its continuation. Broader work on "priming" in prompting exists, but it typically means something different, setting a persona or supplying context up front, not literally pre-writing part of the answer.

That is a real, useful distinction and it's worth saying plainly rather than inventing a pedigree the term doesn't have. The honest primary source here isn't a paper, it's vendor documentation: Anthropic names and documents the actual mechanism, calling it prefilling the assistant's response, in its own API reference. That documentation is genuine and dated. It just isn't a research paper, and the difference matters if you're deciding how much weight the technique deserves.

How do you actually prefill a model's response?

On an API that supports it, you send a request where the conversation's last message has the assistant role and already contains the opening text you want, with no trailing whitespace. Anthropic's own documented example does exactly this:

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "What is your favorite color?"},
        {"role": "assistant", "content": "As an AI assistant, I don't have a favorite color, But if I had to pick, it would be green because"}
    ]
)

The model continues from exactly where that assistant message stops, rather than composing a fresh reply. According to Anthropic's own documentation, this was historically used for three main things: forcing specific output formats like JSON or YAML, skipping introductory preamble text, and holding a role-play persona steady across a long conversation.

Where did output priming actually come from?

It predates the vendor feature that eventually got a name. Before instruction-tuned chat models became the default interface, a raw text-completion API had no separate user turn and assistant turn at all: you sent a block of text, and the model's whole job was to continue it, however it started. Writing the opening words of the "answer" yourself wasn't a technique with a name back then. It was simply how the API worked, since there was no other way to use it.

Chat-formatted APIs changed the shape of the request into distinct user and assistant turns, which is genuinely useful for most conversations, but it also removed the plain continuation behavior by default. Prefilling, as Anthropic built and documented it, is what re-opened that door deliberately: it let you submit a partial assistant turn inside the newer, structured format, so the old completion-era trick still worked even though the underlying API had moved on. That is also, per Anthropic's own migration notes above, the exact door now closing on its newest models.

Does output priming still work on Claude's newest models?

This is a real change to a widely taught trick, not a minor footnote. Anthropic's prefill was, for a long time, one of the more commonly cited formatting techniques on this vendor's platform specifically because no equivalent existed elsewhere. If you built anything around it before 2026, it's worth checking which model you're pinned to.

What should you use instead, now that prefill is going away?

Anthropic's own migration guidance maps directly onto the reasons people used prefill in the first place, and names a specific replacement for each:

If your own use case was the first row, the honest move is to stop hand-rolling a workaround and use the vendor's actual structured output feature. It solves the underlying problem (a guaranteed shape) more directly than a text trick ever did. For the JSON-specific version of this, see Free JSON Prompt Generator.

Does output priming work the same way on ChatGPT or Gemini?

Not as a documented, named feature, based on the vendor pages checked directly for this post. OpenAI's general prompt-engineering guide and its reasoning-specific guidance describe delimiters, system messages and output-format instructions, but neither one describes submitting a partial assistant message as a supported continuation mechanism. Google's Gemini 3 developer guide and its Interactions API reference describe no equivalent either.

That absence is not proof the underlying trick fails on either platform; token-by-token continuation is how all of these models generate text, so a similarly-shaped workaround (asking the model directly to begin its reply with specific words) tends to nudge output in a similar direction. What's missing is the vendor commitment Anthropic built and then partly withdrew: an API-level guarantee that a literal partial answer you submit gets continued rather than restarted. If your workflow depends on that guarantee specifically, Anthropic (on its older models) is currently the only vendor documented as making it.

For where each vendor actually differs on formatting controls generally, see Model-Specific Formatting Cheat Sheet, and for Claude's own XML-based alternative to prefilling for structure, see Using XML Tags in Claude Prompts.

Does output priming work on reasoning models at all?

This is where it gets genuinely different, and it's the part worth not flattening into one rule. Reasoning models change how much any manual scaffolding of the model's process helps, and the vendors say so directly, in different directions for different levers.

OpenAI's reasoning best-practices documentation states: ‘Avoid chain-of-thought prompts: Since these models perform reasoning internally, prompting them to “think step by step” or “explain your reasoning” is unnecessary.’ Google's Gemini 3 developer guide gives matching migration advice: ‘If you were previously using complex prompt engineering (like chain of thought) to force Gemini 2.5 to reason, try Gemini 3 with thinking_level: "high" and simplified prompts.’

Anthropic's documentation takes a genuinely different position on a related but separate lever. Rather than telling you the equivalent trigger is unnecessary, it documents that you can still steer it directly: "The triggering behavior for adaptive thinking is promptable." It publishes sample wording for both nudging the model toward more thinking and toward less. That is not the same claim as OpenAI's or Google's, and it isn't about prefilling the final answer either, it's about whether the model decides to reason at all before it starts.

The upshot for output priming specifically: priming the shape of the final answer (JSON, a fixed opening line) is a different lever from priming whether the model reasons on its way there, and the three major vendors currently document those two levers with three different answers. Don't assume advice about one transfers to the other.

How do you use output priming in a normal chat window, not just the API?

You can't submit a literal partial assistant message through a standard chat interface; that structured input isn't exposed to you there. The closest equivalent in a chat window is asking directly: tell the model to begin its reply with a specific word, phrase, or character, and rely on instruction-following rather than a guaranteed continuation. It usually works, especially on newer models with stronger instruction-following, but it's a request the model can still decline to follow exactly, not a mechanism that constrains the output the way a true prefill or a structured-output schema does.

Does output priming cost extra, in tokens or latency?

Modestly, and it can cut either way. The text you prefill is part of the request you send, not something the model generates from nothing, so on any API billed by input and output tokens separately, a longer prefill adds a small amount to the input side of the bill before the model writes a single new word. Against that, a prefill typically removes a preamble the model would otherwise have generated on its own, which trims output tokens in the other direction. Neither vendor publishes a benchmark isolating that trade-off, so the honest answer is to treat it as roughly a wash rather than assume a meaningful saving or a meaningful cost, and to check your own numbers if the volume is large enough for a percentage point to matter.

What are the real limits of output priming today?

Three, stated plainly. First, the term itself has no traceable academic origin; treat it as practitioner shorthand for a real but narrower vendor mechanism, not as a named research result. Second, that mechanism is actively shrinking: it no longer works at all on Claude 4.6 and later models, and it was never officially documented as a feature on OpenAI's or Google's current platforms in the pages checked here. Third, it doesn't transfer cleanly to the reasoning-model conversation at all, since priming an answer's shape and priming whether a model reasons before answering are different levers that the three major vendors currently treat differently. For a technique in the same family that has an actual paper behind it, with real citable numbers, see Rephrase and Respond Prompting.