How to choose the right Claude model tier for each coding task

When people start building with an AI coding assistant, they often pick the most powerful model available and use it for everything. It feels safe — why not always use the smartest model? But the smartest model is also the slowest and most expensive, and for a lot of everyday work it's overkill. Learning to match the model tier to the task is one of the highest-leverage habits you can build. It saves money, returns answers faster, and — counterintuitively — sometimes produces better results, because a fast model that finishes lets you iterate more.

This guide uses Anthropic's Claude lineup as the example, but the principle applies to every provider that ships a model family.

The tiers, from light to heavy

As of mid-2026, Claude has four tiers, each roughly a step up in capability and price (official pricing):

• Haiku 4.5 — $1 / $5 per million input/output tokens. Fast and cheap. Great for simple, well-defined work.
• Sonnet 4.6 — $3 / $15. The workhorse. Strong at coding and most production tasks.
• Opus 4.8 — $5 / $25. Heavier reasoning for complex, multi-step problems.
• Fable 5 — $10 / $50. The new Mythos-class flagship, released June 9, 2026, for the hardest problems.

Notice that output tokens cost five times input tokens at every tier, and that jumping from Sonnet to Fable is more than a 3x price increase. Those gaps are exactly why tier selection matters.

Anthropic's own rule of thumb

Anthropic's pricing docs give a refreshingly blunt recommendation: "Choose Haiku for simple tasks, Sonnet for most production workloads, and Opus for the most complex reasoning." Fable 5 extends that ladder one rung higher for frontier-level problems.

Translated into coding work:

• Reach for Haiku when the task is mechanical: renaming variables, writing a regex, formatting JSON, generating boilerplate tests, summarizing a diff, or answering a quick "what does this function do?"
• Default to Sonnet for the bulk of real coding: implementing a feature, fixing a normal bug, writing a component, reviewing a pull request. This should be your home base.
• Escalate to Opus when a task needs genuine reasoning across a lot of context: an ambiguous bug with no obvious cause, a multi-file refactor where changes interact, or architectural design decisions.
• Save Fable 5 for the rare problem that defeats Opus — a sprawling migration, a subtle concurrency bug, or work that spans a very large codebase in a single session.

A worked example

Say you're adding a new "export to CSV" feature to a web app. A tier-aware workflow might look like this:

1. Plan with Opus. "Here's my codebase structure. Where should the export logic live, and what edge cases should I handle?" This is reasoning-heavy and sets the direction — worth the better model.
2. Implement with Sonnet. "Write the export function and wire it to a button." Standard coding the workhorse handles well.
3. Test and tidy with Haiku. "Generate unit tests for this function" and "reformat this file." Cheap, fast, mechanical.

The expensive model touches only the 10% of the job that actually needs it. In Claude Code you switch mid-session with /model sonnet or /model haiku; in Cursor you pick from the model dropdown. The whole feature costs a fraction of what it would if Opus or Fable did every step — and finishes faster, because the cheap steps return almost instantly.

Cut costs without dropping a tier

Tier selection is the biggest lever, but two built-in features stack on top of it:

• Prompt caching. If you send the same large context repeatedly (a big system prompt, a file you keep referencing), caching it makes subsequent reads cost just 10% of the input price. For agent loops that re-send context every turn, this is enormous.
• Batch processing. For non-urgent, high-volume jobs — generating tests for 200 files, translating a docs folder — the Batch API runs asynchronously at a 50% discount on both input and output.

Neither changes the model's quality; they just change what you pay for the same work.

The takeaway

Don't default to the biggest model out of caution. Default to Sonnet, drop to Haiku when the task is trivial, and climb to Opus or Fable only when a problem genuinely demands deeper reasoning. You'll spend less, wait less, and — because you can afford to iterate more — often ship better code. The goal isn't to use the smartest model; it's to use the right one for the job in front of you.