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. A factor of twenty.
- 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 (newcomers like Claude Fable 5 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 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.
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.
- 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.
