TL;DR: Reasoning model prompting is mostly subtraction. OpenAI's own docs say telling a reasoning model to think step by step may not help and can hinder; Google says the same about chain-of-thought scaffolding. Give a goal, constraints and an output contract, then stop. Chat models still want the steps.
Most advice on this topic was written in 2024, when there were two obvious buckets: chat models, and a small family of slow expensive ones you sent hard problems to. That world is gone. Reasoning is now a parameter on the same model ID at four of the seven vendors below, it is on by default at most of them, and at two it cannot be switched off at all.
That matters because the habits that make a chat model behave — spelling out the steps, adding worked examples, dropping the temperature for precision — range from useless to actively harmful on a reasoning model, and the vendors say so themselves.
Is a reasoning model a different kind of model?
For prompting purposes, treat "reasoning model" as a product category, not a mechanism you can inspect. No vendor publishes what the model is internally doing when it reasons, and the confident explanations circulating about it are not sourced to anyone who would know.
What vendors do publish is behaviour and controls, and three things are consistent across all seven: the model emits tokens before its answer that are billed as output whether or not you see them, those tokens occupy the context window, and there is a parameter governing how many it may spend. That is the whole observable definition.
OpenAI's catalogue is the cleanest illustration. GPT-4.1 is listed as its "Smartest non-reasoning model", described as having "low latency without a reasoning step" (developers.openai.com). The reasoning models are the ones that have the step. OpenAI's prompt engineering guide gives the framing everyone borrows: "A reasoning model is like a senior co-worker. You can give them a goal to achieve and trust them to work out the details." The operative half is the second one: "A GPT model is like a junior coworker. They'll perform best with explicit instructions to create a specific output" (guide). Its best practices page adds the caveat worth keeping: "One model family isn't better than the other—they're just different."
Which models are reasoning models, and how is the mode switched?
Four switching mechanisms are live: a separate model ID, a parameter on the same ID, always-on with no control, and an injected system prompt.
| Vendor | Reasoning models now | How the mode is switched | Sampling parameters in thinking mode |
|---|---|---|---|
| OpenAI | GPT-5.6 Sol / Terra / Luna, GPT-5.5, GPT-5.4, the Codex variants. GPT-4.1 is the labelled non-reasoning model | Same model ID. reasoning.effort sets depth; GPT-5.6 adds reasoning.mode with standard and pro | Not addressed. The reasoning guide has zero occurrences of temperature, top_p or sampling |
| Anthropic | Opus 5, Sonnet 5, Fable 5.1, Mythos 5.1, Fable 5, Mythos 5, Opus 4.8, Opus 4.7 | thinking: {"type": "adaptive"}, or nothing — several models are always on and reject a disable | Non-default temperature, top_p or top_k return a 400 on the newest models, thinking or not |
| Gemini 3 and 2.5 series | thinking_level. Dynamic thinking is on by default on every listed model except gemini-2.5-flash-lite | Strongly recommends leaving temperature at its default of 1.0 | |
| xAI | grok-4.6, grok-4.5 | reasoning_effort. Reasoning cannot be disabled on either | Presence penalty, frequency penalty and stop return an error |
| DeepSeek | deepseek-v4-flash, deepseek-v4-pro | thinking: {"type": "enabled"} plus reasoning_effort. Enabled by default at high effort | Silently ignored. No error, no effect |
| Alibaba Qwen | Qwen3.8, Qwen3.7, hybrid open-weight series | enable_thinking, passed in extra_body on OpenAI-compatible SDKs. Some models are thinking-only | Not addressed on the thinking page |
| Mistral | mistral-small-latest, mistral-medium-3-5. Magistral is deprecated | reasoning_effort, plus a prompt_mode value of reasoning that swaps in a reasoning system prompt | Not addressed on the reasoning page |
Two rows deserve a second look. Mistral has stopped shipping dedicated reasoning models: its reasoning page points users away from the Magistral small and medium models with a note beginning "Looking for native reasoning models" and says they are deprecated (docs.mistral.ai). Reasoning is now a parameter on the general models, and the OpenAPI spec documents prompt_mode, whose only value is reasoning, as toggling between the reasoning mode and no system prompt. On Mistral, reasoning mode is partly a system prompt the vendor writes for you.
Anthropic publishes the grid to bookmark. Its troubleshooting page lists, per model, which thinking types are accepted, the default, and which values return a 400. Fable 5.1, Mythos 5.1, Fable 5 and Mythos 5 are marked always on and reject both enabled and disabled; Opus 4.8 and Opus 4.7 default to off and reject the legacy enabled mode. Same vendor, same week, four different answers to whether thinking can be turned off (platform.claude.com).
Why does "think step by step" hurt on a reasoning model?
Because the model is already doing it, and your instruction competes with what it is already doing. This is the rare piece of prompting folklore that turns out to be documented rather than invented.
OpenAI states it twice on one page. In prose: "Some prompt engineering techniques, like instructing the model to "think step by step," may not enhance performance (and can sometimes hinder it)." And as a rule: "Since these models perform reasoning internally, prompting them to "think step by step" or "explain your reasoning" is unnecessary" (reasoning best practices).
Google gives the same advice as migration guidance. Its Gemini 3 page opens its prompting section with a sentence that could be this article's title — "Gemini 3 is a reasoning model, which changes how you should prompt" — and then, under migration: "If you were previously using complex prompt engineering (like chain of thought) to force Gemini 2.5 to reason", the fix is a higher thinking level and a simplified prompt. The same section warns that Gemini 3 "responds best to direct, clear instructions. It may over-analyze verbose or overly complex prompt engineering techniques used for older models" (ai.google.dev).
There is also a genuine cross-vendor contradiction, worth knowing before you treat never ask for steps as universal. The only prompting advice for Grok reasoning models anywhere in xAI's documentation sits inside its Microsoft Foundry integration page, under "Prompting Grok effectively", and the first bullet is: "Encourage step-by-step reasoning when needed." (docs.x.ai). Two vendors, opposite instructions, both current. Test on your own task.
What happens to temperature and top_p in thinking mode?
Three different things, and the difference between them is the difference between a bug you find in five minutes and one you never find.
Silently ignored. DeepSeek is the clearest documented case and the most dangerous. Its thinking mode page says the mode does not support temperature, top_p, presence penalty or frequency penalty, then spells out the consequence: "setting these parameters will not trigger an error but will also have no effect" (api-docs.deepseek.com). Thinking is on by default, so every DeepSeek tutorial that opens with a carefully chosen temperature is, on the current models, configuring nothing.
Hard error. Anthropic goes the other way. On Fable 5.1, Mythos 5.1, Fable 5, Mythos 5, Mythos Preview, Opus 5, Opus 4.8, Opus 4.7 and Sonnet 5, non-default temperature, top_p or top_k values "return a 400 error on every request, regardless of whether thinking is used" (platform.claude.com). On older models the restriction applies only while thinking is on. xAI is in the same camp for a different set: presence penalty, frequency penalty and stop "cannot be used with reasoning models. Requests that include them return an error."
Discouraged but permitted. Google's position is advisory. For all Gemini 3 models, "we strongly recommend keeping the temperature parameter at its default value of 1.0", because changing it "may lead to unexpected behavior, such as looping or degraded performance, particularly in complex mathematical or reasoning tasks".
Not addressed. OpenAI's reasoning guide contains zero occurrences of temperature, top_p or sampling. Neither does Alibaba's thinking page or Mistral's reasoning page. Absence is not permission and not prohibition; it is a gap, and the honest move is to say so.
The upshot for anyone maintaining a library: sampling settings are no longer portable. A parameter block that is correct on one vendor is a 400 on the second and a no-op on the third. Our LLM parameter cheat sheet tracks the per-vendor detail.
What are the effort controls, and what values do they take?
Every vendor converged on the same idea and none agree on the vocabulary. This is the most common source of a 400 when porting a prompt between providers.
| Vendor | Parameter | Documented values | Default |
|---|---|---|---|
| OpenAI (GPT-5.6 Sol) | reasoning.effort | none, low, medium, high, xhigh, max | medium |
| Anthropic | output_config.effort | low, medium, high, xhigh, max | high |
thinking_level | minimal, low, medium, high; varies by model | varies by model | |
| xAI | reasoning_effort | low, medium, high, xhigh | high |
| DeepSeek | reasoning_effort | low, high, max | high |
| Alibaba Qwen | reasoning_effort or thinking_budget | varies by model | varies by model |
| Mistral | reasoning_effort | high and none on the docs page | not stated |
Read across and the traps show. xAI has no max — it stops at xhigh, and on grok-4.5, which does not support xhigh, a request for xhigh is silently treated as high. Anthropic has no none, because on several models thinking cannot be turned off. DeepSeek accepts three values but maps five: medium and xhigh are both mapped up to high, so a request asking for less quietly gets more.
Qwen errors if you set both. Alibaba warns that qwen3.8-max does not support setting reasoning_effort and thinking_budget together: "doing so returns an error. When neither is set, the model uses its default." (docs.qwencloud.com). Note the scope: that warning names one model, not the family.
Mistral gives two answers on the same site. Its reasoning page describes only high and none, with none meaning "The model thinks minimally and the thinking chunk is omitted from the response". The OpenAPI spec at docs.mistral.ai/openapi.yaml defines a ReasoningEffort enum with six members: none, minimal, low, medium, high, xhigh. Both read the same day. The model weights repository, which would settle it, returns a 401 as a gated repo.
One more thing before you reach for effort as a length control. Anthropic states that "Effort controls thinking volume, not visible response length", that changing it does not reliably shorten responses, and that you should prompt for length instead (effort). It calls effort "a behavioral signal, not a strict token budget". For a hard ceiling, use a max-tokens limit.
Does every vendor publish reasoning-specific prompting guidance?
No, and the gaps tell you where the folklore comes from.
- OpenAI: yes, two pages. A dedicated best practices page, plus an "Advice on prompting" section on the reasoning guide saying reasoning-capable GPT-5 models "usually work best when you give them a clear goal, strong constraints, and an explicit output contract without prescribing every intermediate step".
- Google: yes. The prompting block on the Gemini 3 page, quoted above.
- Anthropic: yes, and it is the outlier. Its prompting best practices page says "The triggering behavior for adaptive thinking is promptable" and supplies literal prompt wraps for steering it both ways. That is the opposite of OpenAI's position: on Claude, writing about thinking in the prompt is a supported control surface.
- Alibaba: partially. Two prompting guides exist; neither is reasoning-specific.
- xAI: effectively no. One bullet list on an integration page.
- Mistral: no. Its general prompting page contains no reasoning or thinking guidance.
- DeepSeek: no. Its thinking page documents parameters and behaviour, not prompt craft.
What actually changes in the prompt?
| Feature | Written for a chat model | Written for a reasoning model |
|---|---|---|
| Procedure | Numbered steps you specify | Goal plus success criteria; steps left to the model |
| Chain-of-thought instruction | Often helps | Redundant, may hinder |
| Examples | Few-shot lifts consistency | Try zero-shot first, add only if needed |
| Constraints | Implied by the steps | Stated explicitly and up front |
| Output contract | Show the format you want | Define the format as a rule |
| Verbosity | Trim afterwards | Ask for length directly; effort will not do it |
| Sampling parameters | Tune freely | Check the vendor: no-op, 400, or nothing published |
Eight pairs. Same task written twice. The reasoning version is shorter every time, which is the point.
1. Debugging.
CHAT MODEL
You are an expert Python developer. Think step by step. First read the
traceback. Second, identify the failing line. Third, explain why it fails.
Fourth, propose a fix. Fifth, show the corrected code. Work through each
step carefully before moving to the next.
<traceback>
[PASTE]
</traceback>
REASONING MODEL
Find the root cause of this traceback and give me a patch.
Constraints: do not change the public function signature, do not add a
dependency, keep the fix under 20 lines.
Done means: the patch, one sentence naming the root cause, and the one
test case that would have caught it.
<traceback>
[PASTE]
</traceback>
Why it matters: the five steps are the model's job now. What replaces them, constraints and a definition of done, is exactly what OpenAI's guide asks for.
2. Choosing between options.
CHAT MODEL
Compare Postgres and MongoDB for this use case. Go through them one at a
time. For each, list pros, then cons, then a score out of 10. Then compare
the scores and explain your reasoning before recommending one.
Use case: [PASTE]
REASONING MODEL
Recommend one database for this use case and defend it against the
strongest objection to it.
Decide on: write throughput at 5k/sec, schema churn every sprint, a team
of three with no DBA, a 24-month horizon.
Output: the recommendation in one line, the strongest argument against it,
and why that argument does not change the answer.
Use case: [PASTE]
Why it matters: the scoring rubric was scaffolding to force a comparison. Naming the decision criteria instead gives the model something to reason against.
3. Extracting structured data.
CHAT MODEL
Read the document below. Step by step, find each invoice line. For each
one, extract the description, quantity and unit price. Then format them as
JSON. Show your working as you go.
[PASTE]
REASONING MODEL
Return every invoice line in this document as JSON.
Schema: an array of objects with description (string), quantity (integer),
unit_price_cents (integer), confidence (0-1).
Rules: never guess a number. If a field is illegible, set it to null and
set confidence below 0.3. Return the array and nothing else.
[PASTE]
Why it matters: asking it to show its working fights the output contract. A schema plus a rule for uncertainty gets you structured output without the commentary.
4. Writing a plan.
CHAT MODEL
Act as a senior product manager. Create a migration plan. Think about it
step by step: first the risks, then the phases, then the rollback, then
the timeline. Explain your thinking at each stage.
Context: [PASTE]
REASONING MODEL
Write a migration plan for the context below.
Success criteria: every phase is independently revertible, no phase takes
production write traffic offline, and the plan names the specific signal
that triggers each rollback.
Output: a phase table, then the three risks most likely to be missed.
Context: [PASTE]
Why it matters: the persona and the ordering were both proxies for rigour. Success criteria are the direct version, and they are checkable.
5. Reviewing someone else's reasoning.
CHAT MODEL
Review this analysis. Go through it point by point. For each point, say
whether you agree, and explain your reasoning step by step.
[PASTE]
REASONING MODEL
Find the load-bearing assumption in this analysis and tell me whether it
holds.
Output: the assumption in one sentence, the evidence for and against it,
and what the conclusion becomes if it is false.
[PASTE]
Why it matters: point-by-point review produces length, not judgement. Asking for the single load-bearing claim is the task you actually wanted.
6. A judgement call with no clean answer.
CHAT MODEL
Should we deprecate this API? Consider the pros and cons step by step,
then weigh them, then give a recommendation with your reasoning.
[PASTE]
REASONING MODEL
Should we deprecate this API? Answer yes or no in the first line.
Weigh: 340 known integrations, no telemetry on 60% of them, a two-engineer
maintenance cost, a hard security deadline in March.
Then give the deprecation timeline you would defend to the loudest
customer, and the one thing that would change your answer.
[PASTE]
Why it matters: forcing the verdict into line one stops the model hedging through a pros-and-cons list before committing.
7. Long-context analysis.
CHAT MODEL
Here is a 200-page contract. Read it carefully step by step. Summarise
each section, then identify risks, then rank them.
[PASTE]
REASONING MODEL
[PASTE CONTRACT]
Based on the preceding contract, list every clause that creates an
unbounded financial obligation.
For each: the clause reference, the obligation in plain English, and the
worst realistic exposure.
If there are none, say so. Do not summarise the contract.
Why it matters: note the ordering. Google's Gemini 3 guidance is explicit that with large datasets you place the instruction after the data and anchor it with a phrase such as "Based on the preceding information...". That is a reasoning-model-specific placement rule, and the opposite of the role-first habit most chat prompts start with.
8. Creative work, where the advice inverts.
CHAT MODEL
Write a landing page headline. Give me 20 options in different styles.
REASONING MODEL
Write a landing page headline. Give me 20 options in different styles.
Be conversational and generous with variety. Do not converge on one best
answer and stop. Explain nothing.
Why it matters: Google documents that Gemini 3 defaults to less verbose, direct answers and that for a chattier persona "you must explicitly steer the model in the prompt". Anthropic makes the same point about length: effort will not give you a longer answer, so ask. On a chat model this line is usually unnecessary; here it is load-bearing.
Twelve more prompts written for reasoning models
Same shape throughout: goal, constraints, definition of done, no procedure.
9. ROOT CAUSE, NOT SYMPTOM
Here is a bug report and the last three commits. Tell me which commit
introduced the behaviour and why. If none of them did, say so and name
what you would need to see next.
10. THE OBJECTION I AM NOT SEEING
Here is my argument. Give me the objection a hostile expert would raise
that I have not anticipated, and the strongest version of it.
11. ESTIMATE WITH ERROR BARS
Estimate [QUANTITY]. Give a point estimate, a range you would bet on, and
the single input the estimate is most sensitive to.
12. SPEC FROM A MESS
Turn these meeting notes into a spec. Anything the notes do not settle
goes in an OPEN QUESTIONS section rather than being decided by you.
13. WHICH TEST WOULD HAVE CAUGHT IT
Given this incident write-up, name the one test that would have caught it
before deploy, and why it was not written.
14. DISAGREEMENT ON DEMAND
Here is my plan. Argue against it as if you had to stop it. Only then tell
me whether you actually think it is wrong.
15. CONSTRAINT SATISFACTION
Schedule these 14 tasks against these 4 constraints. If the constraints
are unsatisfiable, prove it and name the minimum constraint to relax.
16. THE THING THAT DOES NOT FIT
Here is a dataset summary and a conclusion someone drew from it. Find the
observation that does not fit the conclusion.
17. MIGRATION DIFF
Given this old config and this new schema, produce the migration and the
list of values that cannot be migrated automatically.
18. ONE-LINE ANSWER, THEN THE WORK
Answer in one line first. Then, below a horizontal rule, give the
reasoning that would let a reviewer check the line.
19. PRICE THE TRADE-OFF
Two options below. Do not recommend one. Instead, tell me what has to be
true for each to be correct, in terms I can go and check.
20. STOP CONDITION
Research [TOPIC] until you can answer [QUESTION] with a source. Stop as
soon as you can. Do not gather more than you need.
And eight for when you want less thinking, because on an always-on model a one-word classification still pays for whatever thinking the model decides to do.
21. Classify this ticket into one of: billing, bug, feature, abuse.
Respond with the single word. No explanation.
22. Extract the date from this string as ISO 8601. Output only the date.
23. Rewrite this sentence to be under 12 words. Output only the sentence.
24. Is this email a phishing attempt? Answer YES or NO on the first line,
then at most one sentence of justification.
25. Translate to Spanish. Preserve the markdown. Output only the
translation.
26. Answer this factual question directly. This does not need multistep
reasoning; if you are uncertain, say so rather than working it out at
length.
27. Format this list as a markdown table with the columns I name below.
Do not add, remove or reorder rows.
28. Summarise in exactly three bullets, each under 15 words. Nothing else.
Lowering effort is the other lever. On Claude, telling the model the task is simple is a documented one.
When is a chat model the right answer?
Often, and OpenAI says so plainly: reasoning models "are also generally slower and more expensive to use than GPT models". Its guidance on choosing is unambiguous — if speed and cost matter most and your tasks are straightforward and well defined, the non-reasoning models are the better fit.
The only concrete cost figures any vendor publishes come from Alibaba, and only for one model. Its FAQ explains why qwen3.7-plus feels slow: thinking tokens run at "more than 60% of the total output tokens in measurements", and disabling thinking "lowers total latency by 60% to 75% in measurements". Those are Alibaba's numbers for one hybrid model on its own infrastructure, not a general law. Treat any other percentage on this subject as unverified until you find it on a vendor page.
The decision, stripped down:
- Reasoning model: ambiguity, multi-step planning, code review, anything where the first plausible approach is often wrong, and anything agentic with tools in a loop.
- Chat model: classification, extraction, formatting, translation, drafting from a clear brief, anything on a latency budget.
- Both: the pattern OpenAI recommends, where a reasoning model plans and a cheaper model executes the steps.
If you find yourself switching models mid-conversation to get a better answer, that is often a sign the thread has drifted rather than that the model is wrong. We covered when to start a new chat instead.
What this means for a prompt library
One library now has to carry two dialects, plus a third layer for the vendors whose parameter vocabulary disagrees. A prompt written with five explicit steps and a temperature setting will behave three different ways across three providers, and only one of those ways is an error you will notice.
Prompt Architects sits on the prompt side of that. The extension rewrites a casual prompt into a structured one and lets you pick the platform you are optimising for: per the FAQ, it optimises for models from OpenAI, Google, Anthropic, xAI, Perplexity "and more", with an auto-select option. What it does not have is a reasoning-versus-chat toggle. The model selector is per-platform, not per-mode, so the subtraction described here is still a judgement you make. Choosing which model runs the enhancement itself is Preferred LLM Selection, which the pricing page's comparison table marks Advanced and Team only, not Pro.
The free plan is real: the FAQ publishes "5 prompt enhancements per day, forever" with no card required, though the pricing page renders no Free card, so that figure comes from the FAQ. Pro is $4.99/month for 200 enhancements and Advanced $9.99/month for unlimited, at the time of writing.
For the vendor-specific end of this, our Qwen prompting guide covers that family's thinking-mode switches in detail, and chain-of-thought prompting covers the technique this article tells you to stop using on half your models.
Stop rewriting prompts. Start shipping.
Works with ChatGPT, Claude, Gemini, Grok, Midjourney, Ideogram, Veo3 & Kling. 4.8★ on the Chrome Web Store.
Create An AccountThe short version
Prompting a reasoning model well is subtraction. Delete the procedure, delete the step-by-step instruction, delete the examples you added out of habit, and spend the space on constraints and a definition of done. Then check three things on the vendor's own page before shipping: whether thinking is on by default, what the effort parameter is called and what it accepts, and whether your sampling parameters are honoured, rejected, or quietly thrown away.
All three answers differed across the seven vendors checked here, on the same day.