Which Claude Code Model Should You Use? Let’s Talk Tasks and Costs
Choose between Sonnet 5.5, Opus 5.5, Haiku 5.5 and Fable 5.1 by the work you need done, with current API prices, context tiers, effort and caching costs.
If you asked me which model to choose in Claude Code right now, I’d start you on Sonnet 5.5.
Give it some work. Add a page, connect an API, write tests. When the requirement is clear and the result is easy to check, there’s no need to start with the most expensive option. Move to Opus 5.5 when a bug is hard to pin down or a change touches several modules. I’d save Fable 5.1 for work that is genuinely difficult and needs a sustained investigation.
Haiku 5.5 has a place too. Tagging articles, extracting fields and writing short summaries are high-volume jobs with clear rules. Try it there first. Paying the top model to handle every small item can be unnecessary.
That’s what I want to discuss: choose a model around a real job. A low token price doesn’t guarantee a cheap finished task. If you sit beside it through five rounds of fixes, your time belongs in the bill too.
First, check which version you’re actually running
As of October 12, 2026, the main current lineup in the official docs is Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1.
Installing the latest Claude Code and using the latest model are separate things. Claude Code is the tool; the model behind it depends on your login, provider and settings.
Two people can both say “I use Sonnet” and be talking about different releases. In the current docs, sonnet resolves to 5.5 on the Anthropic API, but may still resolve to 4.5 on Bedrock and Google Cloud Agent Platform. The opus alias on Microsoft Foundry may still point to Opus 4.6.
Check the full ID before comparing experiences. On the first-party API, select it like this:
/model claude-sonnet-5-5
/model claude-opus-5-5
/model claude-haiku-5-5
/model claude-fable-5-1Aliases move over time; a full ID helps you reproduce results. Other providers use their own IDs, and the deployment and account need access. Current Claude Code requirements are v2.1.280+ for Opus 5.5, v2.1.284+ for Sonnet 5.5, v2.1.293+ recommended for Haiku 5.5, and v2.1.257+ for Fable 5.1. Check those before treating a model-selection error as an outage.
How I’d split work between Sonnet and Opus
Take a filter in an admin page. The API exists, the fields are agreed: connect the UI, handle empty results, add a test. I’d try Sonnet first. The work is well defined and you can check the outcome quickly.
Now change the task to “orders occasionally charge twice, and we can’t reproduce it locally.” Did a callback repeat? Did a timeout trigger another attempt? Did the database commit before the response was sent? You need to investigate those together, then prove that ordinary orders and retries still behave correctly.
That’s where I’d put budget into Opus. Its positioning is complex reasoning and longer coding work. Finding the right place to change can take more effort than writing the patch.
Fable goes further: think of migrating a legacy system when its dependencies and migration plan still need investigation. The official docs position Fable 5.1 for demanding reasoning and long-horizon agentic work. If Opus at higher effort still falls short in your evaluations, include Fable in the comparison.
Still, a more expensive model doesn’t invent missing evidence. Without logs, reproduction conditions or business rules, any model has to guess. Fill those gaps before asking it to “think harder” again.
| Model | Where I’d try it first | Official relative latency |
|---|---|---|
| Haiku 5.5 | Classification, extraction, routing, short summaries, small edits | Fastest |
| Sonnet 5.5 | Everyday development, routine fixes, tests | Fast |
| Opus 5.5 | Difficult debugging, complex refactoring, architecture decisions | Moderate |
| Fable 5.1 | Difficult investigations, long autonomous tasks | Slower |
The speed column is the official comparison, not a four-model benchmark I ran. Measure the whole job. Fast output followed by repeated repairs still leaves you waiting; faster generation won’t do much when compilation or an external API is the bottleneck.
Haiku’s price has a detail worth checking
These are standard first-party Anthropic API prices in USD per million tokens, before caching, Batch and other modifiers.
| Model | Input | Output |
|---|---|---|
| Haiku 5.5: prompt up to 100,000 tokens | $0.10 | $0.50 |
| Haiku 5.5: prompt over 100,000 tokens | $0.50 | $2.50 |
| Sonnet 5.5 | $2 | $10 |
| Opus 5.5 | $4 | $20 |
| Fable 5.1 | $10 | $50 |
Haiku’s short-prompt tier is cheap. Carry a long context around and the rate rises. The threshold counts all input per request, including cache reads and writes. Above 100,000, that request uses the higher tier, not just the excess. Earlier requests are not repriced.
Short-text batches and file-heavy agent sessions are different bills. All four models currently have 1M context windows and officially listed maximum output of 128K tokens. That capacity helps investigations, but you don’t need to fill it with dependencies, build artifacts or repeated logs. Give the relevant evidence and filter the rest.
For a simple arithmetic example, assume 50,000 input tokens and 5,000 output tokens in one call, with no caching:
| Model | Cost at that assumed usage |
|---|---|
| Haiku 5.5 | $0.0075 |
| Sonnet 5.5 | $0.15 |
| Opus 5.5 | $0.30 |
| Fable 5.1 | $0.75 |
This is arithmetic, not a same-task benchmark. Real output length, reasoning usage, tool calls and retries differ. With those assumptions, three Sonnet calls cost $0.45 and one Opus call costs $0.30. Rework can erase a unit-price advantage; the table cannot tell you whether Opus actually finishes your task in one call.
Claude Code often runs several rounds: reads files, executes tools, brings results back and revises. Count the whole finished task, not just your first message.
How much cheaper is it than the older version?
Comparing standard token rates only:
| Upgrade | Old input / output | New input / output | Rate change |
|---|---|---|---|
| Opus 5 → 5.5 | $5 / $25 | $4 / $20 | 20% lower |
| Sonnet 4.6 → 5.5 | $3 / $15 | $2 / $10 | About 33.3% lower |
| Sonnet 5 → 5.5 | $2 / $10 | $2 / $10 | Unchanged |
| Haiku 4.5 → 5.5, short prompts | $1 / $5 | $0.10 / $0.50 | 90% lower |
| Haiku 4.5 → 5.5, long prompts | $1 / $5 | $0.50 / $2.50 | 50% lower |
The tokenizer changed too. The official docs say Claude 4.7 and later tokenize the same text into approximately 30% more tokens than earlier models, depending on content. Moving from 4.6 or earlier, a one-third rate reduction does not automatically mean a one-third bill reduction. Count actual requests and compare final usage.
Don’t turn effort all the way up immediately
In Claude Code, Opus 5.5, Sonnet 5.5 and Haiku 5.5 currently default to medium effort; Fable 5.1 defaults to high. These are Claude Code settings, which can differ from defaults on the API model pages.
/effort medium
/effort highStart daily work at medium. If the evidence is complete but the model keeps circling the same change, try high. Setting max for every wording edit adds waiting and can add cost. It won’t recover a missing log.
These models support low, medium, high, xhigh and max, subject to organization settings. opusplan is another option: Opus in plan mode, Sonnet during execution. Consider it when deciding the plan is hard but carrying it out is fairly clear.
To save money, first see where it’s going
A conversation that fixes payments in the morning, changes the homepage later and adds analytics at night can keep carrying old logs and discussion. At a stage boundary, summarize the necessary context and decisions before starting the next stage.
Cache hits currently cost $0.20 per million tokens on Opus 5.5, $0.10 on Sonnet 5.5 and $0.25 on Fable 5.1. Those low rates apply to cache reads; writes have separate rates. Separate ordinary input, cache writes and reads in your calculation.
For API batches that can wait, Batch charges 50% of standard input and output rates. It is asynchronous processing, not an automatic half-price Claude Code interactive session.
Opus 5.5 Fast mode is $8 input and $40 output per million tokens, twice standard pricing, in research preview through the first-party API. It may help if you’re waiting on the model. If you’re waiting on tests, extra spending won’t make them finish sooner.
Pro and Max included usage, extra usage credits and API billing are separate. A session API cost estimate in /usage does not mean that amount was additionally charged. Fable can consume extra credits on some plans and seat tiers; read the picker’s notice before selecting it.
What I’d set up for a solo developer
Start with Sonnet 5.5 + medium for the blog, admin UI and ordinary features. Inspect the code and run the relevant tests. Switch to Opus 5.5 for difficult failures and changes spanning several modules, before spending hours repeating failed attempts.
Try Haiku 5.5 on short-text batches, inspect a sample and expand only if the errors are acceptable. Save Fable 5.1 for harder, longer work; ask what it solves beyond Opus, not just how long it can run.
Take twenty or thirty jobs you actually do, record cost, time, outcome and manual repair time. That will teach you more about your budget than a leaderboard. You’re paying to finish a project; a beautiful response you still have to rewrite isn’t much of a bargain.
Sources
Checked October 12, 2026. Prices, features and relative latency come from official documentation; task recommendations are editorial judgments, not invented personal benchmarks.