📅 Last updated: November 2026

No-nonsense reference for developers who just want to know which AI model to pick. Bookmark this and stop Googling.

📌 Quick pick - just tell me what to use

These are starting points based on available benchmark results and provider pricing, not controlled tests of latency or code quality for each workflow. There is no public benchmark here specifically for documentation or code review.

Features / bugs / tests
Claude Sonnet 5.5
GPT-6.1 Sol
GPT-6.1 Terra
Agentic / CLI / scaffolding
Claude Sonnet 5.5
GPT-6.1 Sol
DeepSeek V4.1 Flash
Architecture / refactors
Claude Fable 5.1 / Opus 5.5
GPT-6 Astra
Gemini 4 Argon
Code review
Claude Sonnet 5.5
GPT-6.1 Sol
Gemini 4 Argon
Documentation
Claude Haiku 5.5
GPT-6.1 Terra
Gemini 3.8 Flash
GitHub Copilot users
Filter the comparison table for availability; see GitHub's price list for Copilot token rates
Design / planning
Claude Fable 5.1 / Opus 5.5
GPT-6 Astra
GPT-6.1 Sol

A note on versions

You’ll see version numbers everywhere: Sonnet 3.5, Sonnet 4, Sonnet 4.5. Gemini 2.5, Gemini 3. GPT-4o, GPT-5.

Don’t overthink it. The tier matters more than the version. “Sonnet” is the mid-tier Claude. “Opus” is the heavyweight Claude. “Flash” is the fast/cheap Gemini. Your IDE usually offers the latest version of each tier - just pick the tier that fits your task.

When this page says “Sonnet”, it means whatever the current Sonnet is. Same for the others.

The big three model families

Speed key: ⚡⚡⚡ Fast · ⚡⚡ Medium · ⚡ Slow

Anthropic (Claude)

Model What it’s for Speed Cost
Haiku 5.5 Fast tasks, scaffolding, CLI ⚡⚡⚡ $0.01/task
Haiku 4.5 Previous Haiku ⚡⚡⚡ $0.10/task
Sonnet 5 / 5.5 Everyday coding ⚡⚡ $0.20/task
Opus 5 Complex reasoning, design ⚡ $0.50/task
Opus 5.5 Higher-end reasoning ⚡ $0.40/task
Fable 5 / 5.1 Frontier reasoning ⚡ $1.00/task
Start with Sonnet 5.5. It lists at $0.20/task. Reach for Opus 5.5 for hard reasoning; Fable is the expensive top tier. Haiku 5.5 costs a tenth of Haiku 4.5 for prompts up to 100K tokens; above that the input and output rates rise fivefold. These estimates use 50K input + 10K output tokens and exclude caching.

OpenAI (GPT)

Model What it’s for Speed Cost
GPT-6 Luna Lightweight, lowest-cost frontier choice ⚡⚡⚡ $0.01/task
GPT-6.1 Terra Mid-tier, half the price of Sol ⚡⚡ $0.10/task
GPT-6 / GPT-6.1 Sol General coding and reasoning ⚡⚡ $0.20/task
GPT-5.6 Luna / Terra / Sol Budget to frontier variants ⚡⚡ to ⚡ $0.02–$0.40/task
GPT-6 Astra Highest-capability tier ⚡ $1.00/task
Skip the "o-series" reasoning models (o1, o3, o4) for everyday coding. They think longer and cost more - o1 is particularly expensive at ~$1.35/task. Save them for:
  • Implementing algorithms (graph traversal, dynamic programming)
  • Debugging race conditions or complex state machines
  • Mathematical proofs or formal verification

Google (Gemini)

Model What it’s for Speed Cost
Gemini 4 Argon Higher-capability tasks ⚡ $0.20/task until Nov 30, 2026, then $0.40
Gemini 3.8 Flash Current fast general-purpose model ⚡⚡ $0.075/task through Dec 31, 2026*
Gemini 3.6 Flash Previous generation ⚡⚡ $0.075/task through Dec 31, 2026*
Gemini 3.5 Flash-Lite Lower-cost, high-volume workloads ⚡⚡⚡ $0.04/task
Gemini 3.1 Pro Previous Pro model (still a preview) ⚡ $0.22/task (≤200K context)

Benchmarks

Want numbers?

The TLDR:

  • LiveBench moved to version 2.0 in October. It now gives models long pieces of real work (extending apps over several rounds, fixing real bugs, building documents, using a browser). The top four are close: Claude Fable 5.1 (85.7), GPT-6 Astra (85.6), Claude Opus 5.5 (85.1) and GPT-6.1 Sol (84.1). These scores aren’t comparable with the LiveBench numbers this page quoted before November.
  • GPT-6.1 Sol is the value pick at the top: 84.1 for about $0.20/task, against $0.40 for Opus 5.5 and $1.00 for Fable 5.1 or Astra. GPT-6.1 Terra scores 77.8 at $0.10.
  • New this month: Claude Haiku 5.5 (69.8 on LiveBench, about $0.01/task) and Gemini 4 Argon (79.3, $0.20/task until Nov 30, then $0.40).
  • On ProgramBench, Claude Opus 5.5 resolved 18.5% of tasks, about twice the next model. The task is rebuilding whole programs from a binary and its docs, so the numbers aren’t comparable with issue-fixing benchmarks.
  • Arena Code has current scores again (October 28), after being stuck at February. Many of the top models are statistically tied there, and older Claude Opus versions still rate as highly as the newest models.
  • SWE-bench Verified and Aider have no scores for 2026 models. SWE-bench’s standardized runs stopped in February apart from one in September, and Aider’s leaderboard stopped in October 2025.

The benchmark page has the per-suite scores, dates and methodology for each source.

Google’s Gemini 3.6/3.8 Flash promotional API rates end Dec 31, 2026. Gemini 3.7 Flash has been withdrawn; Google routes its requests to 3.8 Flash. Gemini 2.5 Pro and 2.5 Flash are deprecated and will be routed to newer models from Dec 1, 2026.

Benchmarks are useful for gut-checking, but the real test is running a model on your own work.

Marketing BS decoder

They say It means
“Most intelligent” Bigger, slower, pricier
“Balanced” Mid-tier - usually right
“Fast” / “efficient” Smaller, cheaper, simpler
“Reasoning” / “thinking” Extra thinking time - see below
“Preview” / “experimental” Unstable - skip it
“200K context” Can see lots of code - but should it?
Opus is NOT a "thinking" model. It's just big and slow. "Thinking" models (o1, o3, Opus-thinking, Sonnet-thinking) explicitly reason step-by-step before responding - you'll see them labeled with "thinking" or "reasoning" in the model name. Regular Opus/Sonnet/GPT-5 are slower because they're larger, not because they're doing extra reasoning passes.
💡 "Thinking..." in the UI ≠ reasoning model. When your IDE shows "Thinking..." or a spinner, that's just the model processing your request - every model does this. True reasoning models show you their actual chain-of-thought (sometimes in a collapsible section), and are explicitly labeled "thinking" or "reasoning" in the model picker. Don't confuse a slow response with deep reasoning.

When do “reasoning” models actually help?

Reasoning models (o1, o3, “thinking” variants) work through problems step-by-step before responding.

Worth it for:

  • Implementing complex algorithms (A*, red-black trees, constraint solvers)
  • Debugging concurrency issues, race conditions, deadlocks
  • Untangling deeply nested dependency chains
  • Mathematical proofs or formal logic

Overkill for:

  • Adding a new API endpoint
  • Fixing a null pointer exception
  • Writing unit tests
  • Refactoring for readability
  • Most day-to-day feature work

A standard model with a good prompt is faster and cheaper for 90% of coding tasks.

What about context window size?

Context window (what’s this?) = how much code the model can “see” at once. Bigger sounds better, but:

  • More context = more noise. The model gets distracted.
  • More context = slower and pricier. You pay per token.
  • You rarely need it. Most tasks involve a few files, not hundreds.

Big windows help for: exploring unfamiliar codebases, analysing logs, multi-file refactors. For everyday coding, focused context beats massive context.

Sources