The Same Prompt Across Six Models (Full Comparison)

TL;DR: Same prompt, different AI: expect different output, and vendor docs explain most of why before you even press enter. This isn't a run we performed. It's the exact test prompt, a scoring rubric, and the documented, dated reasons GPT-5.6, Claude Opus 5, Gemini, Grok, DeepSeek and Kimi diverge, so you can run it yourself.

Type one prompt into ChatGPT, Claude, Gemini, Grok, DeepSeek and Kimi, and you'll get six different answers. That much everyone already knows. The harder question is which differences are real signal about the models, and which are an artifact of how you ran the test: a stale version, a consumer app compared against a raw API, a "creative" setting that means something different at every vendor.

We're not going to show you six screenshots and declare a winner. Here's why, and here's what we built instead.

Why Not Just Run Six Models and Screenshot the Answers?

Building this as a real side-by-side run has an honesty problem: it would mean spending production API credits across six providers to generate outputs for a single blog post, then asking you to trust that our one run, on one day, with unstated settings, represents how "ChatGPT" or "Claude" behaves. It wouldn't. Model behavior shifts with reasoning effort, system prompt placement, temperature (where a vendor even allows it), and which surface you hit, consumer app or API, and a single anecdotal run flattens all of that into "here's what happened when we clicked the button once."

So this post does the other honest thing: it gives you the exact prompt, a scoring rubric built from each vendor's own documented behavior, and a plain scoring sheet, so you can run the comparison yourself, on your own task, and see your own results. Everything below about how the six models are documented to differ is verified against each vendor's current docs, dated 3 September 2026, not narrated as something we watched happen.

The Six Models, and What's Actually Current Today

Model names age fast enough that half the comparisons already online are wrong before publication. Verified today, directly from each vendor's own docs:

• OpenAI: GPT-5.6 Sol. The current flagship, per developers.openai.com/api/docs/models. 1,050,000-token context window, a 128,000-token max output, and a Feb 16, 2026 knowledge cutoff.
• Anthropic: Claude Opus 5. The current recommended model "for most workloads", per platform.claude.com/docs/en/models/overview. Claude Opus 4.8 still exists but is now listed under "Legacy models" on that same page, a stale-model trap this post's own briefing material fell into.
• Google: Gemini 3.1 Pro. Still labeled Preview on Google's own models page as of today, even though it's the Pro-tier flagship. Google's Flash line has already moved two versions past it (Gemini 3.8 Flash, marked Stable).
• xAI: Grok 4.6. Current flagship per docs.x.ai. 500,000-token context window, no published output-token limit.
• DeepSeek: DeepSeek-V4-Pro (model ID deepseek-v4-pro). 1M-token context, 384K max output, thinking mode on by default.
• Moonshot AI: Kimi K3. The flagship model per platform.kimi.ai, with a roughly 1.05M-token (1,048,576) context window shared between input and output.

The Test Prompt

Copy this exactly into a fresh chat on each model, with no saved custom instructions, no memory, no prior conversation in the thread. It's deliberately not a trick prompt; it's an ordinary marketing-writing request with enough constraints buried in it to expose real differences in instruction-following, not just tone.

Act as a senior product marketer. In under 150 words, write three
bullet-point value props for a browser extension that saves and
reuses AI prompts, aimed at solo freelancers.

Rules:
- Each bullet must start with a verb.
- No bullet may exceed 18 words.
- Do not use the word "seamless" anywhere in the response.
- If you're missing information you'd need to do this well, ask
  exactly one clarifying question instead of guessing.
- End with a one-line call to action, formatted in bold.

Every clause in that prompt maps to something a vendor has actually documented behaving differently, which is the point: you're not testing vibes, you're testing specific, checkable behaviors.

What Makes Six Models Answer Differently Before You Even Click Send?

Four documented, dated facts explain most of the divergence you're about to see, independent of which model is "smarter."

Reasoning defaults differ, and reasoning changes how carefully a model checks its own constraints. GPT-5.6 Sol defaults to medium reasoning effort and lets you drop to none. Claude Opus 5 defaults to high and has no off switch. Anthropic's models overview describes adaptive thinking as something that "lets the model decide how much to think, steered by effort", not something you disable. Grok 4.6 defaults to high, and xAI's own docs state it plainly: "Reasoning cannot be disabled." Kimi K3's docs are blunter still: reasoning effort accepts low, high, and max (default max), and "K3 always has thinking mode enabled." A model spending more tokens checking its own output before returning it is documented to behave differently on a "count your words and don't use this word" task than one that answers in one pass, not guaranteed to score higher, just different, and worth knowing before you interpret a result.

"Creative" settings mean three incompatible things. This test prompt has no explicit temperature instruction, but if you're comparing via API rather than a consumer app, know what you're actually controlling. Anthropic's API reference is direct about it: "Models released after Claude Opus 4.6 do not support setting temperature. A value of 1.0 of will be accepted for backwards compatibility, all other values will be rejected with a 400 error." Kimi K3's quickstart is equally direct in the other direction: "temperature=1.0, top_p=0.95, n=1, presence_penalty=0, and frequency_penalty=0 are fixed; omit them from requests." DeepSeek's docs describe its thinking mode as silently ignoring temperature, top_p, and both penalty parameters with no error at all. The parameter is accepted, logged, and does nothing. Three vendors, three different failure modes for the exact same setting.

Determinism is a genuine, sourced disagreement, not vendor folklore. Anthropic's own API reference states plainly: "even with temperature of 0.0, the results will not be fully deterministic." Google's position, verified in earlier research for this project, is the opposite: a temperature of 0 is described as deterministic. If you rerun this test prompt three times per model to check consistency (recommended below), do not assume a temperature-zero API call guarantees an identical answer on every vendor. One of the six explicitly tells you it won't.

Vendors give opposite advice on where instructions belong in a long prompt, which matters if you extend this test prompt with more context later. OpenAI's own prompt-engineering guide says added context is "usually best positioned near the end of your prompt". Anthropic's guidance, by contrast, is to place long documents near the top, with the actual question at the very end. Nobody is wrong; they're describing different architectures, and averaging the advice is worse than following either one consistently.

Token ceilings are shaped three different ways, which matters the moment you add real context to this test. GPT-5.6 Sol publishes a fixed 128,000-token maximum output regardless of how much of its 1,050,000-token window your input uses, up to a 922,000-token input cap; output and input don't trade off against each other below that ceiling. Claude Opus 5 works the same way, with its own fixed 128K output cap. Kimi K3 does not: its maximum output is documented as shrinking dynamically, computed as the remaining share of its roughly 1.05M-token window after your prompt tokens are subtracted, so a longer input directly shortens the longest possible reply. Grok 4.6 is the third shape again: xAI's own docs describe "no text output limit" at all, bounded only by the 500,000-token context window as a whole. Extend this test prompt with a long document and you're testing three different budget architectures, not just three different models.

The Scoring Rubric

Score each model 0–2 per dimension: 0 = ignored the constraint, 1 = partially followed it, 2 = fully followed it. This turns "that answer felt better" into something you can compare across six outputs without relitigating your own taste every time.

Fourteen points possible per model. The rerun-consistency row is the one people skip and shouldn't. A single run tells you what a model can do; three tells you what it reliably does, and that gap is exactly the "not fully deterministic" fact from the section above showing up in practice.

How Do You Run This Comparison Fairly?

A few rules keep the comparison honest, borrowed from how this project verifies vendor claims for every post:

1. Decide API or consumer app, and don't mix them. Anthropic's own Claude Opus 5 system card reports a different refusal rate through the API than through claude.ai: same weights, same evaluation, different surface. A fair six-model comparison picks one surface per vendor and says which, in your notes.
2. Fresh session, every time. No saved custom instructions, no memory, no prior turns in the thread. A model that "remembers" your writing style from an earlier conversation isn't answering the same prompt anymore.
3. Log the raw output before you score it. Score from the transcript, not from memory of reading it, since it's easy to round a partial pass up to a full one after the fact.
4. Note the date and the exact model name or ID, including whether it was Preview or Stable. Five of these six models changed status or version during the writing of this single post; six weeks from now, re-verify before you trust your own scoring sheet.
5. Rerun each model three times before scoring the consistency row. One run measures capability. Three measure reliability, and reliability is usually the more useful number for a production decision.

What Should You Expect, and Why?

We didn't run this prompt across six models for this piece, so nothing below is a report of an output. It's a prediction, grounded in the documented facts above, about where the divergence is likely to concentrate. Treat it as a hypothesis to check against your own run, not a result.

Given that Claude Opus 5 and Kimi K3 keep reasoning permanently on, expect them to be the more reliable performers on the two hard-numeric constraints, the 150-word cap and the 18-word-per-bullet rule, since both spend tokens checking arithmetic before committing to an answer. That's a reasonable inference from the documented defaults, not a guarantee; reasoning effort correlates with more careful checking, it doesn't promise it. Expect the banned-word rule ("seamless") to be the cleanest pass across all six, since avoiding one named word is a much simpler constraint than counting. The likeliest place for a model to fail quietly is the ambiguity clause: a prompt this specific arguably doesn't need a clarifying question, so watch for whether a model still forces one out of habit, which would itself be a data point about how eagerly that vendor's model hedges.

When Is "The Same Prompt" the Wrong Goal?

Once you've run this and watched where the six diverge, the next problem is usually different: you have a prompt that works well on one model and you want to move it, not just compare it. That's where "the same wording" stops being the right target. The field names, placement rules, and stop-sequence limits behind that wording differ by vendor even when the prose doesn't need to change at all. System prompt shape alone has three different names across three vendors for what is conceptually one idea. The mechanics of porting a prompt without it silently breaking are covered in How to Port a Prompt from One Model to Another.

If your six-model comparison includes a reasoning-heavy model behaving oddly on a task that doesn't need step-by-step instructions, that's a separate and well-documented failure mode of its own. OpenAI's own reasoning-best-practices guide is direct about it: telling a reasoning model to "think step by step" or "explain your reasoning" is unnecessary, and the same guide adds that it can sometimes hinder performance. xAI's guidance for Grok says the opposite: "Encourage step-by-step reasoning when needed." Both are current, both are the vendor's own words, and averaging them is exactly the wrong move; pick the vendor's own advice for the model you're actually prompting. Reasoning models and chat models want opposite habits in several other documented cases too, and that's covered in full in Reasoning Models vs Chat Models: Prompt Them Differently.

Keep the Comparison, Not Just the Winner

The useful output of this exercise usually isn't "Model X won." It's the specific failure you found: which model missed the word-count rule, which one hedged when it shouldn't have, which one you can't get to hit zero temperature at all. Save that finding somewhere you'll actually see it again next quarter, because the same six vendors will have shipped new versions by then and the comparison is worth rerunning, not just remembering.