You open GitHub Copilot’s model picker and land on a wine list: GPT-5.5, Claude Opus 4.8, Gemini 3.5 Flash, Haiku, Sonnet, mini, nano, Codex… Which one do you take? The newest? The priciest? The one with the biggest number?
Spoiler: the question “which model is the best?” is the wrong question. The right one is “the best for what?”. We’re going to take the machinery apart — why one model is not another — and then I’ll give you a dead-simple method to find yours, numbers included. And you’ll see: it’s not rocket science.
The through-line: nobody asks “what’s the best vehicle?”
Picture the question asked at a car dealership: “what’s the best vehicle?” The salesman would give you a strange look. The best… for what? Picking up bread? The city car. Moving a piano? The truck. Daily commuting? The all-round sedan.
An AI model is a vehicle. There are nimble city cars, dependable sedans, and semi-trailers that can tow the impossible — but slow and thirsty. And just like at the dealership, everything comes down to a handful of measurable characteristics. Let’s look at them.
Why one model is not another: the 5 differences that matter
1. Engine size — the model’s size
A model is an engine made of billions of internal “dials” (the parameters). More dials means the model picks up more nuance… but every generated word costs more compute. It’s physics: each word of the answer has to travel through the whole engine.
Hence the ranges you see everywhere: nano, mini, Flash, Haiku on one side (small engines, near-instant answers), Opus and the big GPTs on the other (big engines, smarter but slower and pricier).
2. The driver’s experience — the training
Two identical vehicles don’t drive the same depending on who’s behind the wheel. Two models of comparable size don’t “think” the same either: it all depends on what they were taught, and how.
That’s why some models in the picker are code specialists: GPT-5.3-Codex, Raptor mini (a GPT-5 mini re-trained specifically for completion), Kimi-K2.7-Code… At equal size, a specialist often beats a generalist on its home turf. Just like a delivery driver knows the back alleys better than an F1 pilot.
3. The roadmap stop — reasoning
Some models answer straight off the pen. Others — the “reasoning” models — pull over first to study the map: they produce an internal draft, explore leads, correct themselves, and only then answer.
On a thorny problem (a vicious bug, an architecture to rethink), that stop changes everything. To rename a variable? It’s paying a highway detour to reach the end of your street. Reasoning is a billed super-power: extra time and extra tokens.
4. Trunk size — the context window
Every model has a limit on the text it can “see” at once: its context window. Small window: a few files. Large window: some models now reach one million tokens (in VS Code and Copilot CLI), enough to carry a big chunk of the project.
But beware the “bigger = better” reflex: a big trunk only helps if you have luggage. For a syntax question it brings you nothing — and filling it costs money, as we’re about to see.
5. Fuel consumption — the cost
Since June 1, 2026, Copilot has moved to usage-based billing: every exchange consumes AI Credits (1 credit = $0.01) based on the tokens sent to the model, generated by it, and cached. Three things to know, orders of magnitude as I write (official pricing):
- The gap between ranges is huge: ~$0.20–0.50 per million input tokens for the light models, ~$2–2.50 for the versatile ones, $4–10 for the powerful ones — and the top of the range, Claude Fable 5, lists at $10 in and $50 out, double Claude Opus 4.8. A factor of fifty.
- Output costs 4–10× more than input: a chatty model comes at a price.
- Caching cuts input cost by about 90%: staying in one well-set-up conversation is cheaper than resending everything each time.
One example to make it concrete: a round trip that sends ~50,000 tokens of context and generates 5,000 costs roughly 2 credits on a city car… and 40–50 on a semi-trailer. Same conversation, 20× the bill. That’s why “I’ll just use the biggest model everywhere” is a millionaire’s strategy.
The Copilot parking lot, June 2026
Here is the current lineup, sorted by vocation. The list moves every month (models arrive, others retire): the reference remains the official list and the official comparison.
| The range | The models (excerpt) | Built for |
|---|---|---|
| The city cars — light, quick, frugal | Claude Haiku 4.5, Gemini 3.5 Flash, GPT-5 mini / 5.4 nano | Quick questions, small edits, lightweight prototyping |
| The sedans — the everyday all-rounders | Claude Sonnet 5 (and 4.6), GPT-5.4, MAI-Code-1-Flash | The bulk of the work: coding, explaining, testing |
| The semi-trailers — deep reasoning | Claude Opus 4.8, GPT-5.5, Gemini 3.1 Pro | Multi-file refactorings, gnarly debugging, architecture decisions |
| The oversize convoy — the frontier class | Claude Fable 5 | Long autonomous missions: migrations, entire agent work sites |
| The specialized vans — fine-tuned for code | GPT-5.3-Codex, Raptor mini, Kimi-K2.7-Code | Pure engineering tasks, razor-sharp completion |
Bonus: some models also accept images (GPT-5 mini, Claude Sonnet 4.6, Gemini 3.1 Pro) — handy for starting from a screenshot or a mockup.
Spotlight on the oversize convoy: Claude Fable 5
Added to the Copilot catalogue on June 9, Claude Fable 5 opens a category above the semi-trailers: Anthropic’s Mythos class, the first member of the Claude 5 family. Its vocation is not to answer a question faster, but to hold a long mission autonomously — less a chat assistant than a senior colleague you hand an entire work site to.
Three things to know before hitching it:
- Availability: Pro+, Business and Enterprise plans — and on the organization side, the policy is off by default; an admin has to enable it in the Copilot settings.
- Price: billed at the provider’s list price, $10 per million input tokens and $50 for output — double Claude Opus 4.8. The oversize convoy comes at a cost.
- One quirk: as part of its reinforced safeguards, Anthropic retains prompts and outputs for up to 30 days for its safety classifiers.
The advice stays the same as for the rest of the parking lot: measure it in your grid. On a sedan task, Fable 5 is just slower and much more expensive; on a genuine long-haul mission, that’s where it earns its size.
The home test bench: find YOUR model in an hour
Public leaderboards don’t answer the only question that matters: the best for your own tasks, your codebase, your habits. The good news: running your own road test is within everyone’s reach. Five steps.
Step 1 — Pick your 3 typical trips
Take three real, recent tasks from your daily work — not made-up exercises. For example:
- an errand: fix a broken test, write a small function;
- a daily commute: add a medium-sized feature;
- a house move: a multi-file refactoring or an architecture question.
Step 2 — Select 3 candidates
One per range is enough to start: a city car, a sedan, a semi-trailer. No need to test twelve models — you’re comparing ranges, not badges.
Step 3 — Drive clean
This is the step everyone gets wrong. For the comparison to be worth anything:
- same prompt, copy-pasted identically;
- same context (same open files, same
#-references); - fresh conversation for every run — a polluted history skews everything;
- two runs per model: a single answer proves nothing, models have variance.
Step 4 — Score on a grid
Four columns, no more:
- Quality (is the result correct, complete, idiomatic?) — out of 5;
- Round trips needed to reach an acceptable result;
- Time as experienced;
- Credits consumed (visible on your GitHub account’s usage page).
Here’s what it can look like — fictional numbers, for the sake of the example:
| Task | City car (Haiku 4.5) | Sedan (Sonnet 5) | Semi (Opus 4.8) |
|---|---|---|---|
| Fix a broken test | 4/5 · 1 exchange · ~2 credits | 5/5 · 1 exchange · ~8 credits | 5/5 · 1 exchange · ~40 credits |
| Add a feature | 2/5 · 4 exchanges · ~10 credits | 4/5 · 2 exchanges · ~20 credits | 5/5 · 1 exchange · ~45 credits |
| Architecture question | 1/5 · gave up | 3/5 · 3 exchanges · ~30 credits | 5/5 · 1 exchange · ~60 credits |
Step 5 — The verdict… per task type
Read the grid row by row, never as a global score. In the example above, the verdict is not “Opus wins”: it’s “Haiku is plenty for errands (20× cheaper!), Sonnet is my sedan, and Opus is worth every cent on architecture — and only there”.
Redo the exercise every two or three months: models change fast, and so will your ranking.
The 4 traps of the amateur comparer
- The demo effect. A confident, well-written answer is not a correct answer. Check the substance (run the tests!), not the style.
- Judging on a single run. Variance is real. Two runs minimum before concluding.
- The cheating history. If model B runs after model A in the same conversation, it inherits its clues. Fresh conversation, always.
- Forgetting the cost column. An answer that’s 5% better for 20× the price is rarely a good deal — except on moving day.
The simple rule to remember
- By default: the sedan. An all-rounder covers 80% of your days.
- For errands: the city car. Quick question, small edit → light model, instant answer, negligible cost.
- When you’re stuck: the semi-trailer. Two round trips with no progress on a complex problem? Move up a range, state the problem properly once. Then come back down.
- For the long autonomous mission: the oversize convoy. The frontier class (Fable 5) takes on entire work sites — keep the credit meter in sight.
- If your daily work is pure code: try a specialized van.
And above all: don’t trust the benchmarks, the influencers, or me. Trust your grid. Three tasks, three models, one hour of road testing — that’s all it takes to know what drives best at your place.
One model is not another: not because marketing says so, but because the engine size, the training, the reasoning, the trunk and the fuel consumption differ — and now you know how to read the spec sheet.
And that, when you get down to it… is not rocket science.
