How to Prompt Reasoning Models: 7 Principles That Work Across Every Model

Reasoning models — OpenAI GPT-5.5 with its reasoning-effort levels, Claude with extended thinking, Gemini 3.1 Pro — think internally before answering, and that inverts the prompting playbook. Chain-of-thought instructions like "think step by step" are redundant on a model already reasoning in hidden tokens, and often counterproductive: they either double-bill the reasoning by narrating it in the response, or constrain the internal pass to your script. State the goal and constraints, not the procedure. Direct the depth of thinking; don't try to elicit it.

This guide is deliberately model-agnostic. It covers the 7 principles that hold no matter which reasoning model you use, the standard-prompt-versus-reasoning-prompt rewrites that make those principles concrete, and the reasoning-effort mechanics (GPT-5.5's reasoning-effort levels, Claude's budget_tokens) you tune on every call. For the full per-model "dialect" rundown — exactly how GPT-5.5, Claude extended thinking, Gemini 3.1 Pro, and DeepSeek V4 each differ, the model landscape table, and the six-slot prompt anatomy — see the comprehensive pillar: Prompting Reasoning Models in 2026: the complete guide. Read this post to learn the principles; read the pillar to pick and tune a specific model.

What Are Reasoning Models?

Reasoning models are a class of language models that perform internal chain-of-thought reasoning before producing a visible response. Unlike standard models that generate tokens sequentially from left to right, reasoning models allocate dedicated computation — sometimes called test-time compute — to think through a problem before committing to an answer.

The three major reasoning model families in 2026 are:

• OpenAI GPT-5.5 — OpenAI's flagship, where the old separate o-series has been folded into GPT-5.5's reasoning-effort levels (none/low/medium/high/xhigh). The GPT-5.4 family (GPT-5.4, mini, nano) covers cheaper, faster tiers that still reason internally.
• Claude with extended thinking — Anthropic's approach. Sonnet 4.6 and Haiku 4.5 use configurable extended thinking (thinking tokens appear in a separate block from the final response); Opus 4.8 and the top-tier Claude Fable 5 use always-on adaptive thinking.
• Gemini 3.1 Pro and Gemini 2.5 Pro — Google's reasoning models, where the model generates and evaluates multiple hypotheses in parallel before answering.

What makes these models fundamentally different from standard models like GPT-5.4 nano, Claude Haiku, or Gemini Flash-Lite is where the reasoning happens. In a standard model, the only reasoning that occurs is in the visible output — which is why chain-of-thought prompting works so well on them. You're literally giving the model space to reason by asking it to "think step by step."

In a thinking model, the reasoning happens in hidden tokens that you never see (or see in a separate thinking block). The model has already done the step-by-step work internally. Your job shifts from eliciting reasoning to directing it.

Why Traditional Prompting Advice Backfires

This is where most people get tripped up. The techniques that made you effective with earlier standard models — the GPT-4 and Claude 3 generation — can actively hurt your results with reasoning models.

The chain-of-thought paradox

On a standard model, adding "think step by step" to a math problem boosts accuracy. On GPT-5.5 or Claude with extended thinking, the same phrase is wasteful at best and counterproductive at worst.

Why? The model is already thinking step by step — internally, using dedicated thinking tokens. When you ask it to also think step by step in the visible output, one of two things happens:

• The model narrates its internal reasoning in the final answer, doubling the token cost without improving quality. You pay for the thinking tokens AND the narrated reasoning.
• The model constrains its internal reasoning to match your specified steps, potentially missing better approaches it would have found on its own.

Here's what this looks like in practice:

--- STANDARD MODEL (GPT-5.4 nano) ---

Prompt: "A farmer has 847 sheep. He sells 293, buys 156 more, then 
loses 12% of his flock to disease. How many sheep remain? 
Think step by step."

This works well. The model writes out each step, catches errors,
and arrives at the correct answer.

--- REASONING MODEL (GPT-5.5) ---

Prompt: "A farmer has 847 sheep. He sells 293, buys 156 more, then 
loses 12% of his flock to disease. How many sheep remain?"

No "think step by step" needed. GPT-5.5 already runs the calculation
internally across its reasoning tokens. The answer is correct 
and concise. Adding "think step by step" would just make the 
response longer without improving accuracy.

Over-specifying steps constrains the model

This is subtler and more damaging. When you give a reasoning model a detailed procedure — "First do X, then do Y, then do Z" — you're replacing its reasoning with yours. And the model's reasoning is usually better than the procedure you'd write, because it can explore approaches you wouldn't think of.

--- OVER-SPECIFIED (hurts reasoning models) ---

Prompt: "Review this code for security vulnerabilities. 
Step 1: Check for SQL injection. 
Step 2: Check for XSS. 
Step 3: Check for CSRF. 
Step 4: Check for authentication bypasses. 
Step 5: Summarize findings."

--- GOAL-ORIENTED (works with reasoning models) ---

Prompt: "Review this code for security vulnerabilities. 
Focus on issues that could lead to data exposure or 
unauthorized access. Rank findings by severity."

The first prompt limits the model to four categories of vulnerability. The second lets the model apply its own expertise, which might surface issues you never thought to look for — race conditions, insecure deserialization, SSRF, logic flaws in business rules.

Few-shot examples can hurt

On standard models, few-shot examples are one of the most reliable prompting techniques. You show the model two or three examples of input-output pairs, and it pattern-matches to produce the right format.

On reasoning models, few-shot examples for reasoning tasks can backfire. The model may anchor on the reasoning pattern in your examples instead of applying its own deeper analysis. For classification, formatting, and style tasks, few-shot examples still work fine. But for tasks where you want the model to actually think — problem-solving, analysis, debugging — let it think without anchors.

The 7 Principles of Reasoning Model Prompting

These principles apply across GPT-5.5, Claude extended thinking, and Gemini 3.1 Pro. Model-specific techniques come later.

1. State the goal, not the steps

Tell the model what success looks like, not how to achieve it. Reasoning models are path-finders — give them the destination and let them find the route.

--- WEAK ---
"Analyze this dataset by first calculating the mean, then the 
median, then the standard deviation, then identifying outliers 
using the IQR method, then summarizing trends."

--- STRONG ---
"Analyze this dataset. Identify the most important statistical 
patterns and any anomalies that would affect business decisions. 
Present findings in order of significance."

2. Give hard problems, not easy ones

Reasoning models have a minimum useful complexity. Simple tasks — summarizing a paragraph, translating a sentence, classifying sentiment — don't benefit from internal reasoning. The model spends thinking tokens on a problem that doesn't need them, and you pay for that computation without getting better results.

Reserve reasoning models for tasks that genuinely benefit from deliberation: multi-step math, code architecture decisions, legal analysis, research synthesis, debugging, strategic planning.

3. Let the model choose its approach

This is the hardest principle for experienced prompt engineers. You've spent years learning to be prescriptive — specifying frameworks, methodologies, and analysis structures. With reasoning models, that prescription becomes a ceiling.

Instead of "Use the SWOT framework to analyze this business," try "Analyze this business's competitive position. Use whatever analytical framework best fits the situation." The model may choose SWOT. It may combine multiple frameworks. It may invent an approach tailored to the specific business. All of these are likely better than forcing SWOT on a problem that might not suit it.

4. Provide constraints, not procedures

There's a critical difference between constraints and procedures. Constraints define the boundaries of acceptable output. Procedures define the path to get there.

Constraints (good for reasoning models):

• "Keep the response under 500 words"
• "Only use information from the provided documents"
• "All code must be Python 3.12 compatible"
• "Do not recommend solutions that cost more than $10,000/month"

Procedures (often harmful for reasoning models):

• "First read the document, then extract key points, then..."
• "Start by listing all variables, then..."
• "Begin your analysis with a summary of..."

Constraints let the model reason freely within boundaries. Procedures force it onto a track.

5. Use verification requests

One area where you should be prescriptive with reasoning models: asking them to check their work. Reasoning models can still make mistakes, and explicitly requesting verification causes the model to allocate additional thinking tokens to double-checking.

"Solve this optimization problem. After reaching a solution, 
verify it by checking it against the original constraints 
and testing with edge cases."

"Write a function that handles concurrent database writes. 
Before finalizing, check for race conditions, deadlocks, 
and data integrity issues."

Verification requests don't constrain how the model thinks — they add a quality gate at the end.

6. Separate output format from reasoning

Tell the model what to think about and how to format the answer in distinct sections. Mixing formatting instructions into the problem description clutters the reasoning space.

--- MIXED (cluttered) ---
"Analyze the following contract and list each risk as a bullet 
point with the clause number in bold and a severity rating of 
high/medium/low in parentheses, making sure to consider 
indemnification limits, liability caps, and termination clauses."

--- SEPARATED (clean) ---
"Analyze the following contract for legal risks. Consider all 
clauses that could expose us to financial liability, operational 
disruption, or compliance issues.

Format: Bullet list. Each item: **Clause [number]** — 
[risk description] (severity: high/medium/low)"

The separated version lets the model think about risks without simultaneously worrying about formatting. The formatting instructions are there, but they're clearly secondary to the analytical task.

7. Budget your thinking tokens wisely

Every reasoning model charges for thinking tokens. GPT-5.5 and Claude extended thinking both bill for the internal reasoning that you may never see. This means that using a reasoning model on a simple task isn't just slower — it's more expensive for no benefit.

Budget thinking tokens by adjusting the model's reasoning effort parameter (covered in the effort-parameter section below) rather than by writing shorter prompts. A short prompt with high reasoning effort is better than a long prompt with low reasoning effort.

Setting Reasoning Effort: The One Mechanic You Can't Skip

The principles above are about what you say to a reasoning model. There's one mechanic about how hard it thinks that is just as important — and it lives in an API parameter, not in your prompt text. Every reasoning model exposes a depth dial, and tuning it is the difference between truncated reasoning on a hard problem and a wasted bill on an easy one.

GPT-5.5: reasoning_effort

OpenAI's GPT-5.5 exposes a reasoning_effort parameter with levels — none, low, medium, high, and xhigh — that controls how many thinking tokens the model allocates before responding. The old standalone o-series has been folded into these effort levels.

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-5.5",
    reasoning={
        "effort": "high"
    },
    input="Design a distributed caching system that handles 
           10 million requests per second with sub-millisecond 
           latency. Consider consistency models, eviction 
           policies, and failure modes."
)

Low effort — Straightforward questions that need some reasoning but not deep analysis: coding tasks with clear specs, factual questions that require synthesis.

Medium effort — The default for most tasks: analysis, multi-step problems, writing that requires planning.

High or xhigh effort — Complex math, formal proofs, multi-file code generation, problems with many interacting constraints. Use these when accuracy matters more than speed or cost.

Claude extended thinking: budget_tokens

On Sonnet 4.6 and Haiku 4.5, Claude controls thinking through a budget_tokens parameter that caps the tokens used for internal reasoning (minimum 1,024 tokens, billed at output rates). The top-tier models — Opus 4.8 and Claude Fable 5 — use always-on adaptive thinking instead, deciding how deeply to reason on their own.

import anthropic
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6-20260412",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "Review this database schema for a multi-tenant 
                    SaaS application. Identify design flaws that 
                    would cause problems at scale."
    }]
)

Set the budget too low on a hard problem and the model truncates its reasoning mid-thought; set it too high on an easy one and you pay for nothing. The rule across both APIs is the same: set depth via the parameter, not via prose. Phrases like "think very carefully about this" do not move the dial — they just consume input tokens.

Each model has its own dialect — the pillar covers them

Beyond the shared effort dial, each model rewards a different prompting dialect: GPT-5.5 leans on structured-outputs JSON schemas, Claude rewards XML-tagged content and tail-pinned output formats, Gemini 3.1 Pro rewards opening the problem space for its parallel hypothesis exploration, and DeepSeek V4 actually rewards the explicit step-by-step requests that backfire everywhere else. Those per-model specifics — plus the full 2026 model landscape table and the six-slot prompt anatomy — are out of scope for this principles-first guide. For the complete per-model rundown, see the pillar: Prompting Reasoning Models in 2026: GPT-5.5, Claude, Gemini, DeepSeek V4.

When NOT to Use Reasoning Models

Not every task benefits from reasoning. Using a reasoning model for simple tasks is like using a scanning electron microscope to check if your plants need watering — technically it works, but you're wasting time and money.

Tasks that don't need reasoning models:

• Quick content generation. Writing a tweet, drafting a short email, generating a product description. Standard models handle these fine and respond faster.
• Simple Q&A. "What's the capital of France?" doesn't need 10,000 thinking tokens.
• Conversational interactions. Chatbots, customer support, casual dialogue. Reasoning models often overthink conversational tasks and sound stilted.
• Formatting and transformation. Converting between data formats, restructuring text, applying consistent formatting rules.
• Classification. Sentiment analysis, topic labeling, spam detection. These are pattern-matching tasks, not reasoning tasks.

The cost calculus:

Reasoning models charge for thinking tokens on top of input and output tokens. On a simple task, thinking tokens are pure waste. On a complex task, they're the difference between a wrong answer and a right one.

A practical heuristic: If you could solve the task yourself in under 30 seconds with full context, a standard model is probably sufficient. If the task requires you to consider multiple interacting factors, weigh tradeoffs, or follow a chain of logic through several steps, reach for a reasoning model. For a broader walkthrough of which AI model to use for your task, see our complete selection hub.

Practical Examples: Standard Prompt vs Reasoning Model Prompt

The following five examples demonstrate how to adapt prompts when switching from a standard model to a reasoning model. The standard prompts work well on GPT-5.4 nano, Claude Haiku, or Gemini Flash-Lite. The reasoning model prompts are optimized for GPT-5.5, Claude with extended thinking, or Gemini 3.1 Pro.

Example 1: Complex Math/Logic Problem

--- STANDARD MODEL PROMPT ---

"A company has 3 factories. Factory A produces 40% of total 
output with a 2% defect rate. Factory B produces 35% with a 
3% defect rate. Factory C produces 25% with a 5% defect rate. 
A randomly selected product is defective. What's the 
probability it came from Factory C?

Think step by step:
1. Calculate P(defect) for each factory
2. Calculate total P(defect)  
3. Apply Bayes' theorem
4. Show your work"

--- REASONING MODEL PROMPT ---

"A company has 3 factories. Factory A produces 40% of total 
output with a 2% defect rate. Factory B produces 35% with a 
3% defect rate. Factory C produces 25% with a 5% defect rate. 
A randomly selected product is defective. What's the 
probability it came from Factory C?

Verify your answer by confirming the posterior probabilities 
for all three factories sum to 1."

The standard model prompt spells out Bayes' theorem step by step — because without that guidance, GPT-5.4 nano might take shortcuts. The reasoning model prompt states the problem and adds a verification request. GPT-5.5 or Claude with thinking will apply Bayes' theorem (or whatever approach it prefers) on its own.

Example 2: Code Architecture Decision

--- STANDARD MODEL PROMPT ---

"We need to add real-time notifications to our app. 
Currently we have a REST API with PostgreSQL.

Consider these options:
1. WebSockets with Socket.io
2. Server-Sent Events (SSE)
3. Polling with long-poll fallback
4. A managed service like Pusher or Ably

For each option, analyze:
- Implementation complexity
- Scalability to 100K concurrent users
- Cost implications
- Impact on existing architecture
- Maintenance burden

Then recommend one with justification."

--- REASONING MODEL PROMPT ---

"We need to add real-time notifications to our app. 
Currently using a REST API with PostgreSQL, deployed on 
Vercel with serverless functions. Team of 3 engineers.
Expected scale: 100K concurrent users within 12 months.

Recommend a real-time notification architecture. Optimize 
for time-to-ship and operational simplicity given our 
small team. Flag any approach that would require 
re-architecting our existing API."

The standard prompt hand-holds through the analysis. The reasoning model prompt provides context that matters (serverless deployment, small team, timeline) and states the optimization criteria. The model will consider options you haven't listed and weight them against your actual constraints.

Example 3: Research Synthesis

--- STANDARD MODEL PROMPT ---

"Summarize the key findings from these three papers on 
transformer attention mechanisms. For each paper:
1. State the main hypothesis
2. Describe the methodology
3. List key results
4. Note limitations

Then compare the three papers and identify areas of 
agreement and disagreement."

--- REASONING MODEL PROMPT ---

"These three papers all study transformer attention 
mechanisms but reach different conclusions about the 
role of multi-head attention.

Identify the core disagreement. Determine which paper's 
methodology most convincingly supports its claims. If 
you had to design a follow-up experiment to resolve 
the disagreement, what would it test?"

The standard prompt asks for structured summarization — a task standard models handle well with explicit guidance. The reasoning model prompt asks for judgment: which methodology is strongest, and what experiment would settle the debate. This requires deep reasoning that benefits from extended thinking.

Example 4: Strategic Analysis

--- STANDARD MODEL PROMPT ---

"Our SaaS product has 5,000 users and $50K MRR. 
Churn is 8% monthly. 

Perform a SWOT analysis:
- List 3 strengths
- List 3 weaknesses
- List 3 opportunities  
- List 3 threats

Then suggest 3 strategic priorities for the next quarter."

--- REASONING MODEL PROMPT ---

"Our SaaS product has 5,000 users and $50K MRR. Churn 
is 8% monthly. Customer acquisition cost is $200. 
Average revenue per user is $10/month. We have 18 months 
of runway.

8% monthly churn means we lose half our users every 
8 months. At current CAC and ARPU, we can't grow our 
way out of this. 

What are the highest-leverage moves to fix unit 
economics before runway runs out? Be specific about 
what to do in the next 30 days vs the next 90 days."

The standard prompt asks for a textbook SWOT exercise. The reasoning model prompt presents a genuine strategic dilemma with real constraints (runway, unit economics) and asks for a time-bound action plan. The model can reason about the interplay between churn, CAC, ARPU, and runway in ways that a paint-by-numbers SWOT can't.

Example 5: Debugging Complex Issues

--- STANDARD MODEL PROMPT ---

"This function throws a NullPointerException intermittently 
in production. Here's the stack trace and the relevant code.

Step 1: Identify all places where null could be introduced.
Step 2: Check thread safety of shared state.
Step 3: Review the database query for edge cases.
Step 4: Suggest a fix."

--- REASONING MODEL PROMPT ---

"This function throws a NullPointerException intermittently 
in production — roughly 0.1% of requests. It only happens 
under load (>500 RPS). The function works correctly in all 
unit tests and staging environments.

Here's the stack trace and the relevant code. Find the bug.

[code and stack trace]"

The standard prompt prescribes a debugging procedure. The reasoning model prompt provides the symptoms that actually matter — intermittent, load-dependent, not reproducible in tests — and lets the model reason about what class of bug fits those symptoms. A reasoning model will likely consider concurrency issues, connection pool exhaustion, or caching race conditions without being told to look for them.

Building Prompts for Reasoning Models With SurePrompts

The principles in this guide — goal-oriented framing, constraints over procedures, verification requests, separated output formats — can be applied manually, but it's tedious to restructure every prompt from scratch.

Our prompt generator helps here. It builds structured prompts with role context, clear constraints, and output specifications already separated from the task description. You describe what you need in plain language, and the generator produces a prompt that works well with both standard and reasoning models.

This is especially useful when you're transitioning from standard to reasoning model prompting and need to break the habit of over-specifying steps.

The Future of Reasoning Model Prompting

Reasoning models are still early. The gap between effective and ineffective prompting on these models is larger than it was on standard models — because the models are more capable, there's more performance to unlock (or leave on the table).

A few trends to watch:

Adaptive reasoning will become the default. Claude's always-on adaptive thinking on Opus 4.8 and Claude Fable 5 — and GPT-5.5's reasoning-effort levels — are early versions of what will become automatic reasoning allocation. The top Claude models already decide how hard to think on their own; for the configurable models, tuning reasoning effort by hand is still a meaningful lever.

Reasoning costs will drop. GPT-5.4 mini and DeepSeek V4-Flash already demonstrate that strong reasoning doesn't require the largest, priciest models. Expect reasoning-capable models at every price point within the next year.

Prompting will become more about problem formulation. As models get better at choosing their own reasoning approaches, the skill shifts from "how to make the model think" to "how to frame the problem so the model thinks about the right things." This is closer to how you'd brief a smart colleague than how you'd write code.

The best prompt engineers in 2026 aren't the ones who write the longest, most detailed prompts. They're the ones who state problems clearly, provide the right constraints, and then get out of the model's way.

If you want to practice applying these principles, start with our prompt generator to build a structured prompt, then deliberately strip away any procedural instructions. State the goal, add your constraints, request verification, and let the reasoning model do what it was built to do.

For the full per-model rundown — how GPT-5.5, Claude extended thinking, Gemini 3.1 Pro, and DeepSeek V4 each differ, the 2026 model landscape, and the six-slot prompt anatomy — see the comprehensive pillar: Prompting Reasoning Models in 2026. For adjacent deep dives, see advanced prompt engineering techniques for Claude, GPT-5, and Gemini and chain-of-thought prompting fundamentals.