Prompting Reasoning Models in 2026: GPT-5.5, Claude Opus 4.8, Gemini 3.1 Pro

If your prompt library still says "let's think step by step" on every hard question, you're optimizing for 2022. The model lineup in mid-2026 looks different — and so does the playbook.

Today's reasoning tier isn't o1/o3 as the default names users see. ChatGPT runs GPT-5.5 with adjustable reasoning depth. Claude's workhorse for deep analysis is Opus 4.8 with extended thinking, with Fable 5 and Mythos 5 at the new frontier. Gemini pairs Gemini 3.1 Pro for hard tasks with Gemini 3.5 Flash for speed. GPT-5.6 is starting to roll out to users in staged access.

These models think internally before they answer. Prompting them like GPT-4o — long system prompts, CoT scaffolding, five few-shot examples — often hurts instead of helps. This article is the 2026 map: what changed, how each provider differs, and what to write instead.

The split: chat models vs reasoning models

Chat / instruct models answer in one pass. They benefit from examples, role prompts, and explicit "think step by step" on hard logic.

Reasoning models allocate hidden thinking tokens (or adaptive thinking) before visible output. They already search internally. Your job is problem specification — goal, constraints, context, output format — not process narration.

Wrong model class is expensive. GPT-5.5 on high reasoning effort for email extraction burns money and latency. Gemini 3.5 Flash on a novel architecture tradeoff gives shallow output. Route first, prompt second.

2026 model landscape (what users actually pick)

OpenAI / ChatGPT

• GPT-5.5 — current mainstream reasoning-capable model. Reasoning depth via reasoning_effort (none / low / medium / high / xhigh on API; Thinking mode in ChatGPT UI).
• GPT-5.6 — rolling out in stages to users and approved partners. Same prompting principles as 5.5; treat as next-gen until you have access and evals on your tasks.
• Legacy o-series (o3, o4-mini, etc.) — still in some API configs, but consumer and most new work has moved to GPT-5.x with effort levels. Don't copy o3-specific blog posts without checking your actual model ID.

Anthropic / Claude

• Claude Opus 4.8 — deep work with configurable extended thinking (thinking.budget_tokens on Sonnet-class configs; Opus uses adaptive/extended modes per plan).
• Claude Fable 5 — frontier tier for demanding reasoning and long-horizon agents. Adaptive thinking (effort parameter), not the old fixed budget-only pattern.
• Claude Mythos 5 — same underlying capability as Fable 5, restricted access (e.g. Project Glasswing partners). Prompting behaves like Fable 5; availability does not.
• Claude Sonnet / Haiku 4.x — extended thinking available on capable tiers; lighter default for speed.

Google / Gemini

• Gemini 3.1 Pro — primary reasoning tier. Thinking mode / thinking budget on API for multi-step analysis, code, math.
• Gemini 3.5 Flash — fast, cheap default. Not your choice for hard reasoning; excellent for extraction, classification, high-volume chat.

Others worth knowing

DeepSeek R1, Grok heavy modes, etc. follow the same prompting inversion: clear spec, minimal scaffolding. This article focuses on the big three you named.

What broke from the GPT-4 era

"Think step by step" — redundant or harmful on reasoning tiers. See our dedicated article; summary: reasoning models already do this internally.

Long expert personas — confidence steering without accuracy gain. Short audience/behavior constraints beat "world-class expert."

Few-shot CoT examples — can lock the model into mimicking visible chains instead of free internal search. Default zero-shot; add examples only if evals prove help.

Low max_tokens — on GPT-5.5, completion budget covers thinking + answer. 1024 tokens can mean empty visible response after thinking consumes the cap.

Temperature tuning — many reasoning endpoints ignore or lock temperature. Don't optimize a dead knob.

Parsing full reasoning in production — unless you explicitly need audit trails, ask for structured conclusions only.

Universal principles (all providers)

1. State the goal and success criteria. What does correct look like?
2. List constraints and edge cases upfront. Reasoning models won't magically know your business rules.
3. Specify output format mechanically. JSON schema in API, or "3 bullets, max 20 words each" in chat.
4. Provide domain context explicitly. Reasoning models trade breadth for depth — paste specs, don't assume recall.
5. Keep system prompts short. Two or three focused instructions beat ten pages of persona.
6. Zero-shot first. Escalate to one precise example only after measurement.
7. Match reasoning depth to task difficulty. Not every query needs max effort.

OpenAI GPT-5.5: prompting specifics

Reasoning effort is the main dial. Low for quick logic; high or xhigh for planning, proof-like work, ambiguous tradeoffs.

Token budget: set max_completion_tokens high enough for thinking + output — often 8k–16k+ on non-trivial tasks. If you get truncated answers, raise the cap before rewriting the prompt.

Prompt style: problem statement + constraints + desired output. No CoT scaffolding.

Structured output: use API json_schema for machine consumption; keep the prompt for semantics inside fields.

ChatGPT UI: Thinking / higher effort modes map to the same idea — don't stack manual step-by-step instructions on top.

GPT-5.6: as access expands, re-run your eval suite. New tiers sometimes shift cost/latency curves; prompting shape stays goal-constraint-format.

GPT-5.5 example — bad vs good

Bad (2022 habit): "You are a genius CFO. Let's think step by step. Analyze whether we should acquire Acme Corp given the attached metrics..."

Good: "Decide recommend / do-not-recommend / need-more-data for acquiring Acme Corp. Criteria: (1) DCF payback under 4 years, (2) no customer concentration above 25%, (3) integration cost under $2M. Use only the metrics below. Output: JSON with keys decision, rationale (max 3 sentences), risks (array of strings). [metrics]"

Claude Opus 4.8 and Fable 5: prompting specifics

Opus 4.8 + extended thinking: configurable thinking budget on API (thinking.budget_tokens separate from output max_tokens on supported configs). More budget → deeper search → higher cost/latency.

Fable 5 / Mythos 5: adaptive thinking via effort parameter. You steer depth, not step-by-step prose. Anthropic docs recommend same core techniques as other Claude models — short prompts, explicit context, XML tags for long documents.

Delimiters: Claude handles <document>, <instructions>, <output_format> blocks well. Separate data from rules.

Don't over-prompt thinking: asking Claude to "show every step" in the visible channel can shallow out internal reasoning on some configs. If you need audit, request a brief rationale field after the answer.

Minimal system prompt: Anthropic guidance for extended thinking — long system prompts constrain search space. Cut fluff.

Claude example — code architecture review

Bad: "Act as a principal engineer with 20 years experience. Think carefully step by step through this design..."

Good: "Review this API design for a payment webhook handler. Flag: idempotency gaps, retry safety, PII in logs. Context: [paste OpenAPI excerpt]. Format: markdown table | Issue | Severity (high/med/low) | Fix suggestion |. Max 8 rows."

Fable 5 note: best for multi-hour agentic workflows and hardest reasoning. Opus 4.8 remains the practical default for most teams until Fable capacity and pricing fit your budget. Prompt shape is the same — depth knob differs.

Gemini 3.1 Pro vs 3.5 Flash

Gemini 3.1 Pro — use for math, code review, multi-constraint planning, scientific analysis. Enable thinking / set thinking budget on API when available.

Gemini 3.5 Flash — default for volume: summarize, classify, extract, rewrite, simple Q&A. Standard chat prompting works: RTF framework, few-shot if needed, CoT phrase acceptable on hard single-step logic.

Routing rule: if wrong answer costs more than extra seconds of latency, Pro. If task is pattern-matching at scale, Flash.

Schema: Gemini respects response_json_schema with property ordering — useful for reasoning-first vs answer-first field order.

Gemini example — when to use which

Task: classify 10k support tickets into 12 internal labels → 3.5 Flash, few-shot or structured output, no thinking mode.

Task: evaluate whether a SQL migration plan causes downtime on a 500GB table → 3.1 Pro, thinking enabled, full DDL + constraints pasted, output as numbered risk list.

Reasoning effort / thinking budget cheat sheet

| Situation | GPT-5.5 | Claude | Gemini |

| Hard ambiguous analysis | high / xhigh | extended thinking / Fable effort high | 3.1 Pro + thinking budget |

| Medium logic, some nuance | medium | moderate budget | 3.1 Pro default |

| Simple but needs correctness | low | thinking off or small budget | 3.1 Pro low thinking |

| High-volume structured extract | reasoning_effort none → or use mini/Flash | Haiku / no thinking | 3.5 Flash |

Always validate on your eval set. Tables are starting points, not laws.

Hybrid workflows that work in production

Scout + solver: Gemini 3.5 Flash scopes and extracts facts → GPT-5.5 / Opus 4.8 / Gemini 3.1 Pro decides on the condensed packet.

Formatter last: reasoning model produces analysis → cheap model formats to JSON/email/Slack if schema enforcement isn't in API.

Verifier pass: reasoning model answers → second call (same or different model): "Given this answer and source text, list any unsupported claims." Catches overconfidence without visible CoT.

Before / after rewrites (cross-provider)

Legal clause comparison

Before: "You are a senior attorney. Let's think step by step and compare these two NDAs."

After: "Compare NDA A and NDA B on: term length, mutual vs one-way, carve-outs for public info, jurisdiction. Quote clause text for each difference. Output: markdown table. If a term is missing, write MISSING. [paste both NDAs]"

Debugging production incident

Before: "Expert SRE, think step by step through this outage..."

After: "Root-cause hypothesis for 502s starting at 14:32 UTC. Stack trace and deploy log below. Return: most likely cause (1 sentence), evidence (3 bullets), next check (1 command). [logs]"

Math / planning

Before: "Let's work this out step by step. Maria buys 6 apples at 3-for-$2..."

After: "Calculate total cost. Reply with number only. Maria buys 6 apples (3 for $2) and 10 oranges (5 for $4)."

Common mistakes in June 2026

Using Opus 4.8 or GPT-5.5 high effort for tasks Flash handles at 1/10 the cost.

Copying o3-era prompts without checking model ID is GPT-5.5.

Assuming Fable 5 is default — it's frontier; most users still on Opus 4.8 or Sonnet until plan/capacity allows.

Triple scaffolding: expert role + think step by step + few-shot CoT on a reasoning model.

Truncated answers from token caps misdiagnosed as "model isn't smart enough."

Ignoring GPT-5.6 staged rollout — pin model version in production configs.

When standard chat prompting still wins

Gemini 3.5 Flash bulk tasks.

Creative writing where internal reasoning adds latency without quality gain.

Strict format compliance with few-shot on non-reasoning tiers.

PromptMake /text generation targeting a fast chat model — optimize for clarity and RTF structure, not reasoning depth.

PromptMake workflow

Know your model class first. Then use promptmake.net/text to tighten goal, constraints, and format from a rough ask. Guest: 3/day; registered: 5/day on /text. For image pipelines, /image is separate.

PromptMake won't pick GPT-5.5 vs 3.5 Flash for you — routing is architecture. It removes blank-page friction once you've chosen.

Frequently asked questions

Is o3 dead?

Not everywhere in API, but user-facing ChatGPT center of gravity is GPT-5.5 with reasoning effort. Update docs and evals to match what you actually call.

Opus 4.8 or Fable 5?

Opus 4.8 for most deep work today. Fable 5 when you need frontier reasoning/agents and have access. Same prompt shape; different depth and cost.

What's Mythos 5 for prompt engineers?

Same as Fable 5 in behavior; restricted deployment. If you don't have access, ignore it for day-to-day prompting.

Gemini 3.1 Pro or 3.5 Flash for coding?

Hard refactor / architecture / subtle bug → 3.1 Pro. Boilerplate, tests from spec, simple fixes → 3.5 Flash.

Should I ask to see thinking traces?

For debugging prompts, sometimes useful on Claude. On models with hidden thinking, forcing visible reasoning can reduce quality. Prefer structured final output + optional short rationale field.

GPT-5.6 — change prompts?

Unlikely. Re-benchmark cost, latency, and accuracy when you migrate.

Related articles

Why "think step by step" is dead in 2026 — the CoT inversion explained.

Chain-of-thought when to use — external CoT on chat vs internal on reasoning.

Few-shot vs zero-shot — zero-shot default on reasoning tiers.

Structured output — API schema for conclusions reasoning models produce.

RTF framework — still works as the chat-side skeleton before you strip scaffolding for reasoning.

Bottom line

Mid-2026 reasoning lineup: GPT-5.5 (with 5.6 rolling out), Claude Opus 4.8 and frontier Fable 5 / Mythos 5, Gemini 3.1 Pro for depth and 3.5 Flash for speed.

Prompt them with clear goals, complete constraints, explicit context, and mechanical output format — not step-by-step theater. The o3-era name-dropping in your templates is a smell. Match the model on the invoice, then write for that architecture.