There is no single best model among GPT, Gemini and Claude; the right choice depends on the task, the budget and the tools you already use. As of October 2026, all three providers sell a flagship model, a mid-priced workhorse and a low-cost model, all three now offer context windows of about one million tokens, and their published prices for comparable tiers sit close together. The bigger practical differences are in how each family wants to be prompted, which is why the same prompt can work well in one model and poorly in another.
Photo: mikemacmarketing, CC BY 2.0, via Wikimedia Commons.
This comparison does two things. First, it lays out the current model line-ups and prices from each provider’s own documentation, with a way to choose by task. Second, it shows how to adapt one prompt for ChatGPT’s models, Gemini and Claude, using each provider’s official prompting guidance, with a worked before-and-after example.
The current line-ups, from official documentation
Each provider now offers three broad tiers: a flagship for the hardest reasoning and coding work, a balanced model for most production use, and a fast, cheap model for high-volume tasks. The table lists API prices per million tokens as published on 24 October 2026. Consumer apps (ChatGPT, Gemini, Claude.ai) are sold by subscription and may route you to different models or apply different limits.
| Provider | Model (API ID) | Context window | Max output | Input / output per 1M tokens |
|---|---|---|---|---|
| OpenAI | GPT-6 Astra (gpt-6-astra) | 1,050,000 | 128K | $10 / $50 |
| OpenAI | GPT-6.1 Sol (gpt-6.1-sol) | 1,050,000 | 128K | $2 / $10 |
| OpenAI | GPT-6 Luna (gpt-6-luna) | 1,050,000 | 128K | $0.10 / $0.50 |
| Gemini 4 Argon (gemini-4-argon) | 1,048,576 (shared by input, thinking and output) | 65,536 default; longer with long decode | $2 / $10 until 30 Nov 2026; $4 / $20 from 1 Dec 2026 | |
| Gemini 3.8 Flash (gemini-3.8-flash) | 1,048,576 | 65,536 | $0.75 / $3.75 until 31 Dec 2026; $1.50 / $7.50 from 1 Jan 2027 | |
| Gemini 3.5 Flash-Lite (gemini-3.5-flash-lite) | 1,048,576 | 65,536 | $0.30 / $2.50 | |
| Anthropic | Claude Fable 5.1 (claude-fable-5-1) | 1M | 128K | $10 / $50 |
| Anthropic | Claude Opus 5.5 (claude-opus-5-5) | 1M | 128K | $4 / $20 |
| Anthropic | Claude Sonnet 5.5 (claude-sonnet-5-5) | 1M | 128K | $2 / $10 |
| Anthropic | Claude Haiku 5.5 (claude-haiku-5-5) | 1M | 128K | $0.10 / $0.50 for prompts up to 100K tokens; $0.50 / $2.50 above |
Some pricing rules are easy to miss in the headline numbers:
- OpenAI long prompts: on the GPT-6 models above, a request with more than 272K input tokens is billed at twice the input rate and 1.5 times the output rate for the whole request.
- Anthropic long prompts: Anthropic’s pricing page says its current models other than Haiku 5.5 charge the same per-token rate across the full 1M window. Haiku 5.5 is the exception, with higher prices once a prompt passes 100,000 tokens.
- Google’s scheduled increases: the Gemini 4 Argon and Gemini 3.8 Flash prices above are introductory and roughly double on the dates shown.
- Batch and caching discounts change the effective price a lot for repeated or non-urgent work. They are compared in detail in the context caching pricing comparison.
One takeaway from the table: at the mid tier, GPT-6.1 Sol, Gemini 4 Argon (at its introductory price) and Claude Sonnet 5.5 list the same $2 input and $10 output. Price alone will rarely settle the choice.
How to choose by task
Choosing well means matching the tier to the stakes of the task first and the provider second. Benchmark leaderboards shift with every release and rarely match your exact workload, so the practical questions are these:
- How costly is a wrong answer? Legal analysis, production code changes and anything customer-facing justify a flagship or mid-tier model plus human review. Classification, tagging, extraction and drafting routine replies usually run fine on the cheapest tier.
- How much do you send per request? If you regularly send hundreds of thousands of tokens, the long-prompt pricing rules above matter more than the base price.
- Where does your work already live? Gemini integrates with Google Search grounding and Google Workspace; ChatGPT and the OpenAI API have their own tool ecosystem; Claude has tight integration with coding tools and the Model Context Protocol. Switching cost is real.
- Does the task need current information? Every model has a training cutoff. For recent facts, use a setup with search or retrieval, and say in the prompt whether the answer should come from live sources or from the model’s existing knowledge.
- Do you need predictable structured output? All three support JSON schemas through their APIs; the schema syntax differs in small ways, so test the exact schema you plan to use.
The only reliable tiebreaker is your own test. Take eight to ten real tasks from your work, write a scoring rubric before you look at any output (accuracy, format compliance, unsupported claims you can check), run the same tasks on two or three candidate models and score them blind if you can. The method is described in more depth in how to evaluate AI models with your own evals. Repeat the test when a provider ships a new version; many teams end up using two models, a cheap one for volume and a stronger one for difficult cases.
Adapting prompts for ChatGPT, Gemini and Claude
All three providers agree on the fundamentals of prompting: clear instructions, relevant context, examples of the output you want and a defined format. Where they differ is in emphasis, defaults and a few model-specific behaviors documented in their official guides. The table below summarizes those differences.
| Aspect | OpenAI (GPT-6 family) | Google (Gemini) | Anthropic (Claude) |
|---|---|---|---|
| Where standing instructions go | The instructions parameter or a developer message, which take priority over user messages | The system instruction; Google advises putting critical constraints, persona and output requirements there or at the start | The system parameter |
| Structuring a prompt | Markdown headings and lists for sections; XML tags to mark where documents start and end | XML-style tags or Markdown headings, but pick one format and use it consistently in a prompt | XML tags with consistent, descriptive names, nested for documents |
| Long documents | Context usually near the end of the developer message | All context first, the question at the very end | Long material at the top, the query and instructions after it |
| Examples | A diverse range of inputs with desired outputs | Google recommends always including few-shot examples, formatted identically | 3 to 5 relevant, varied examples in <example> tags |
| Default style | Astra tends toward detailed, formatted answers; ask for prose if you want it | Gemini 3 and later are concise by default; ask explicitly for detail or a conversational tone | Follows instructions precisely; ask explicitly for anything beyond the bare task |
| Reasoning control | reasoning.effort (for example low to max on GPT-6.1 Sol) | Models think internally; you rarely need to ask for visible step-by-step reasoning | Adaptive thinking with an effort setting |
| Sampling parameters | Remove temperature and top_p when reasoning effort is not none | Gemini 4 and 3.6+ ignore custom temperature, top_p and top_k | Effort and max_tokens are the main levers on current models |
For the API parameter side of reasoning control, see the reasoning effort parameters comparison. The rest of this section focuses on the wording of the prompt itself.
Prompting the GPT-6 models
OpenAI’s guidance separates who is speaking: the developer message holds the application’s rules, and the user message holds the input, much like a function definition and its arguments. OpenAI’s prompting guide also distinguishes reasoning models, which it says do well with high-level goals, from non-reasoning GPT models that need more precise, explicit instructions. The GPT-6 guide adds that GPT-6 Astra is more sensitive to everything in its context, including agent and skill files, and recommends auditing those files and stating which instructions win when they conflict. If you want short prose answers, say so, because Astra tends to produce detailed, formatted responses.
Prompting Gemini
Google’s prompting strategies page asks for direct, precise wording and for ambiguous terms to be defined. Two habits matter most. First, for long inputs, give all the context first and place the specific question at the very end. Second, because Gemini 3 and later default to concise answers, request the level of detail you need. Google also suggests using its Search grounding for recent or obscure facts and code execution for arithmetic and counting, and, for some Flash models, stating the current year and a strict “answer only from the provided context” clause when that is what you need.
Prompting Claude
Anthropic’s best-practices page stresses explicitness and reasons. Claude does what it is asked rather than guessing at more, so a request for a “dashboard” gets a basic one unless you ask for a fuller build. Explaining why a rule exists helps the model apply it sensibly; Anthropic’s example is telling the model its output will be read by a text-to-speech engine instead of simply banning ellipses. It also recommends describing the format you want rather than the one you do not want, and notes that aggressive wording such as “CRITICAL: you MUST” can make newer models over-apply a rule. Asking whether Claude can “suggest” changes gets suggestions; telling it to “change” the code gets edits. The fuller treatment is in how to write a system prompt.
Worked example: one task, three adapted prompts
The task below is illustrative: summarizing a long customer-interview transcript for a product team. Here is the generic version many people paste into any chatbot:
Summarize this interview and tell me the key insights.
[transcript]It works everywhere and is good nowhere: no audience, no format, no rule about quotes, and the instruction sits before a long document. Below is the same task adapted to each provider’s documented preferences. The core content (audience, output, evidence rule) is identical; the packaging changes.
GPT-6 version (developer and user messages)
DEVELOPER MESSAGE
# Identity
You summarize customer interviews for a B2B product team.
# Instructions
- Audience: product managers deciding what to build next quarter.
- Output: a short paragraph overview, then up to 5 insights.
- Each insight: one sentence, followed by one verbatim quote
from the customer that supports it.
- If the transcript does not support an insight, leave it out.
- Write plain prose with simple bullets; no tables, no bold.
USER MESSAGE
<transcript>
[transcript]
</transcript>The Identity and Instructions headings follow the developer-message structure OpenAI describes. The final formatting line counters Astra’s tendency toward heavily formatted answers.
Gemini version (system instruction, question last)
SYSTEM INSTRUCTION
You summarize customer interviews for a B2B product team.
Write for product managers deciding what to build next
quarter. Use only the transcript; do not add outside
knowledge.
PROMPT
<transcript>
[transcript]
</transcript>
<task>
Based on the transcript above, write a short paragraph
overview, then up to 5 insights. Give each insight as one
sentence followed by a verbatim customer quote that supports
it. Explain each insight in enough detail that someone who
did not hear the interview understands why it matters.
</task>The task comes after the transcript, as Google recommends for long context, and uses one delimiter style throughout. The line asking for enough detail compensates for Gemini’s concise default.
Claude version (XML tags, reasons, document first)
SYSTEM
You summarize customer interviews for a B2B product team.
Product managers use your summaries to decide what to build
next quarter, so every insight must be traceable to what the
customer actually said.
USER
<transcript>
[transcript]
</transcript>
First, pull the passages from the transcript that show a
need, a complaint or a workaround into <quotes> tags.
Then write a short paragraph overview and up to 5 insights
in <summary> tags. Each insight is one sentence followed by
the supporting quote. Write in flowing prose apart from the
insight list. If a possible insight has no supporting quote,
leave it out.The system prompt explains why traceability matters instead of only demanding it. Extracting quotes first follows Anthropic’s advice for long documents, and the format is described positively (“write in flowing prose”) rather than as a ban.
Notice what did not change: the audience, the output shape and the evidence rule. Those are what turn a generic prompt into a useful one on any model. The provider-specific packaging is a second layer of tuning, and its effect should be checked with your own test set, and re-run whenever a model version changes so that an upgrade does not quietly change results.
When the choice of model matters less than the prompt
For everyday writing, summarizing and analysis, a specific prompt with context, constraints and an example output usually moves quality more than switching providers. Model choice matters most at the edges: very long inputs where pricing tiers kick in, agentic coding and tool use where providers’ tooling differs, tasks that depend on live search, and regulated work where data handling terms decide for you. If a task fails on one model, fix the prompt first, then try the same prompt elsewhere; changing both at once tells you nothing about which change helped.
