Claude Model Tiers Explained: Haiku vs. Sonnet vs. Opus vs. Fable
Most Claude users pick a model once and never touch the picker again. We did the same for the first few weeks. Then one afternoon the usage limit hit in the middle of a task that actually mattered, and we realized the heaviest model in the list had been renaming files and polishing two-line emails all day.
So we ran a deliberate experiment. We took a week of real, mixed work (sorting messy lists, drafting emails, debugging, planning a small system, and a multi-file cleanup) and routed each task through the Claude tiers on purpose. This guide is what came out of it: a simple rulebook for choosing between Haiku, Sonnet, Opus, and Fable, a quick-recall sheet for anyone studying for a Claude certification, and the real examples where each model earned its place. We start with the decision guide itself, because that is the part most readers want first.
Visual Decision Guide: Which Model Should You Pick Right Now?
Run your task through these questions in order and stop at the first "yes." The diagram below shows the same path visually.
Still unsure? Start with Sonnet, then move up or down based on the result.
For a second view, here is how the four tiers compare on three qualities. This is a relative, illustrative picture based on our own experience, not a benchmark score.
Relative comparison (illustrative)
Speed
Reasoning depth
Credit burn per task
Two escalation signals tell you to move up a tier:
- The answer looks right but skips something you asked for.
- The answer is plausible but you cannot explain why it is correct.
And one signal to move down: you are waiting a long time for a simple answer.
The Four Pillars of the Claude Ecosystem
The current Claude family has four tiers, and each one is built for a different kind of work.
- Haiku: the fastest and lightest tier. It suits high-volume, low-ambiguity work where speed matters more than depth.
- Sonnet: the balanced everyday model. It handles writing, general coding, summaries, and normal conversation well.
- Opus: the deep-reasoning tier. It is meant for problems with competing constraints, ambiguity, and real consequences.
- Fable: the frontier tier above Opus. It is designed for long-horizon, multi-step work where the model plans, acts, checks itself, and carries on with minimal check-ins.
Plan availability matters here. In our experience, Haiku and Sonnet are the models you find on lighter plans, while Opus and Fable generally sit on paid plans or API access. Anthropic adjusts which plans include which models, so treat the table below as a starting map and confirm what your own picker shows.
| Tier | Speed | Reasoning Depth | Typical Access | Credit Burn |
|---|---|---|---|---|
| Haiku | Fastest | Light | Broadly available, including lighter plans | Lowest |
| Sonnet | Fast | Strong, balanced | Broadly available, usually the default | Moderate |
| Opus | Slower | Deep | Generally paid plans or API | High |
| Fable | Slowest per task, but works through long jobs on its own | Deepest, with long-horizon planning | Generally paid plans or API | Highest |
Prefer a quicker version? Here's a short video summary of the four Claude tiers and how to pick between them.
In the video:
- The decision guide for choosing between Haiku, Sonnet, Opus, and Fable
- What each tier does best, with real examples
- Why using the heaviest model for everything burns credits and slows you down
Haiku: Speed and High-Volume Work
Haiku surprised us in the best way. When the task is clear and the answer is short, it responds almost instantly, and that changes how you work. You stop waiting and start iterating.
Where Haiku worked well for us:
- Sorting a pasted list of 60 mixed expense lines into categories.
- Tagging article drafts by topic.
- Reformatting text, such as converting notes into a clean table or changing date formats.
- Quick lookups like "what does this error code generally mean?"
Where it struggled was any task that needed the model to hold several conditions in mind at once. When we gave it a request with four overlapping rules, it followed three and quietly dropped the fourth. The answer looked complete, which made the miss easy to overlook. That is the typical Haiku failure: a confident, tidy, slightly incomplete result.
Sonnet: The Everyday Default
Sonnet is where most of our week was spent, and it should be where most of yours is spent too. It writes clean prose, explains concepts well, handles ordinary coding, and follows multi-part instructions reliably.
Tasks Sonnet handled without complaint:
- Drafting and tightening professional emails.
- Summarizing long documents and meeting notes.
- Writing and explaining typical functions, SQL queries, and small scripts.
- Planning a week of content or a study schedule.
The practical test we kept using: if a smart colleague could do the task in one sitting without special expertise, Sonnet is probably enough. We only moved up a tier when Sonnet's first answer was plausible but shallow, or when the problem had hidden trade-offs.
Opus: Complex Reasoning and Hard Trade-Offs
Opus earns its cost on problems where a wrong answer is expensive. We used it for a design question with real trade-offs: how to structure a small reporting pipeline so it stays maintainable when the data sources change. Sonnet gave a reasonable layout. Opus pushed back on our assumptions, pointed out a failure case we had not considered, and explained why one of our "simple" shortcuts would cause trouble later.
Good reasons to reach for Opus:
- Architecture and design decisions with competing constraints.
- Refactoring code where behavior must not change.
- Ambiguous problems where the real task is working out what to ask.
- Reviewing a plan for gaps before you commit to it.
The trade-off is speed and credits. Opus is slower and uses more of your allowance per request, so it works best as a deliberate escalation, not a default.
Fable: Autonomous Multi-Step Execution
Fable is a different kind of tool. The earlier tiers are mostly conversational: you ask, they answer, you steer. Fable is built for jobs where you describe the outcome and let it work through many steps, checking its own progress and fixing its own mistakes along the way.
Our best Fable test was a multi-file cleanup. We handed it a small project with inconsistent naming, duplicated helper functions, and outdated comments, and asked for a consolidated, consistent version. Instead of answering file by file and waiting for us, it planned the order of changes, worked through them, noticed when one change broke another, and corrected it. We reviewed the result at the end instead of supervising every step.
Two honest notes. First, Fable on a small task is wasteful: you pay for planning machinery you do not need. Second, the same frontier model family carries extra safeguards around sensitive areas such as biology and cybersecurity, so a perfectly legitimate security-adjacent request may meet more caution than you expect. If that happens, rephrase with clear, legitimate context, or use a different tier for that part of the work.
The Cost and Credit Trap: Why Using Opus for Everything Hurts Your Workflow
Here is the mistake we made ourselves. We left the heaviest model selected "just to be safe," and it felt sensible. Better model, better answers, right? In practice it backfired in three ways.
- Limits run out faster. Heavy tiers use more of your allowance per message. Small tasks added up and the limit arrived before the important work did.
- Simple tasks got slower. Waiting on a deep-reasoning model to rename ten files is a poor use of anyone's afternoon.
- Over-thinking crept in. For straightforward requests, the heavier models sometimes gave longer, more hedged answers than we needed.
The mirror-image mistake is just as real: pushing a genuinely hard problem through Haiku to save credits, then spending twice the time fixing the incomplete result. We covered a related pattern in the productivity trap, where AI creates more work than it saves, and wrong-model choices are one of the easiest ways to fall into it.
Where We Actually Used Each Model: Real Examples
Theory only goes so far, so here is what each tier handled for us in practice. These come from our own working sessions, and they are the cases that shaped the rulebook.
| Model | Real Task | What Happened |
|---|---|---|
| Haiku | Quick back-and-forth chat to talk through an idea, such as outlining a topic or sanity-checking a naming choice | Replies came back almost instantly, so the conversation felt natural. Perfect for thinking out loud; we never needed more depth. |
| Haiku | Tagging and sorting a pasted list of items | Fast and accurate, as long as the rules were simple. It broke down once we stacked four rules together. |
| Sonnet | Writing Azure deployment and Kubernetes configuration (deployment, service, and config files) | Produced clean, well-structured manifests and explained each section. We still reviewed values before applying anything to a real cluster. |
| Sonnet | Summarizing a long meeting transcript into action items | Reliable structure on the first pass, with no need to escalate. |
| Opus | Setting up a complex Spring Boot application framework: layered structure, configuration, security, and database integration decisions | Opus questioned our assumptions about module boundaries and configuration, and flagged choices that would have caused trouble later. This was the kind of decision where depth paid for itself. |
| Opus | Debugging an intermittent bug that only appeared sometimes | Sonnet guessed at causes. Opus reasoned through the timing and found the likely culprit. |
| Fable | Cleaning up a small multi-file project with inconsistent naming and duplicated helpers | Planned the order of changes, worked through them, caught its own breakage, and handed back a consistent result for review. |
The pattern is easy to see once the examples sit side by side. Conversation and sorting went to Haiku, configuration and everyday build work went to Sonnet, architecture decisions went to Opus, and long self-directed jobs went to Fable. None of these choices was about prestige. Each one was about matching effort to the task.
Studying for a Claude Certification? Quick-Glance Model Sheet
If you are preparing for a Claude foundation-level exam or any Claude certification, being able to recall the four tiers in seconds is a useful skill. Exam syllabi change, so always check the official exam guide for what is actually covered. What we can offer is the memory sheet we built for ourselves while working through the material in our guide to free Claude courses and certification.
| Tier | One-Line Memory Hook | Think Of It As | Pick It When | Avoid It When |
|---|---|---|---|---|
| Haiku | A haiku is short, so Haiku is for short, quick tasks. | The sprinter | Speed, volume, and simple rules matter most | Many overlapping rules or deep logic are involved |
| Sonnet | A sonnet is structured and balanced, so Sonnet is the balanced default. | The all-rounder | Everyday writing, coding, summarizing, and planning | Hidden trade-offs or costly mistakes need deeper reasoning |
| Opus | An opus is a major work, so Opus is for major problems. | The specialist | Architecture, ambiguity, and high-stakes reasoning | The task is simple and speed or credits matter |
| Fable | A fable is a long story, so Fable is for long, multi-step jobs. | The autonomous worker | A clear outcome needs many steps with few check-ins | The task is small or the goal is still vague |
A few recall tips that helped us:
- Order by size and cost: Haiku, Sonnet, Opus, then Fable moves from lightest to heaviest. Cost and depth rise together, while speed falls.
- Remember the default: when a question asks for a sensible everyday choice, the balanced middle option is usually the intended answer.
- Match the verb: "sort or tag" points to Haiku, "write or summarize" to Sonnet, "design or reason through" to Opus, and "carry out end to end" to Fable.
- Trade-off thinking: expect scenario questions that ask you to balance speed, quality, and cost instead of naming the biggest model.
A Practical Workflow You Can Copy
- Start every task on Sonnet. It is the right answer most of the time.
- Drop to Haiku when you are doing the same simple operation many times, or just chatting an idea through.
- Escalate to Opus when Sonnet's answer feels shallow, or when the cost of being wrong is high.
- Hand the whole job to Fable when the outcome is clear but the path is long.
- Check the result against the original request, whichever tier produced it.
The quality of your request matters as much as the model. Model choice gets better when the instructions are good, and we went deeper on that in our walkthrough of giving AI the right information at the right time. If you use Claude for recurring work, setting up a Claude Project with saved instructions means you stop re-explaining the task each time and can swap tiers without losing context.
Limitations and Failure Scenarios
- Haiku on complex logic produces confident but incomplete outputs. This was our most common failure.
- Opus or Fable on trivial tasks wastes allowance and time with no quality gain.
- Fable without a clear brief can run confidently in the wrong direction. Define the outcome and the boundaries first.
- Generated configuration still needs review. Whether a Kubernetes manifest came from Sonnet or Opus, check names, resource values, and secrets handling before applying it anywhere real.
- Plan details change. Which model appears on which plan, and how much of it you can use, shifts over time. Always check your own picker and usage display instead of trusting any article, including this one.
- Our results are one team's workload. Your mix of tasks will differ, so treat our routing table as a starting hypothesis and adjust it.
How Model Choice Fits the Bigger Picture
Choosing a tier is one decision in a larger stack. We compared the wider field of current models in our side-by-side look at the latest Gemini, GPT, and Claude releases, and we explored what happens when a model has to work independently for hours in our notes on building AI agents that actually work. Fable-style autonomy makes that second article more relevant than it used to be.
Key Takeaways
- Default to Sonnet, and move up or down deliberately.
- Haiku is for speed, chat, and volume, not for multi-rule reasoning.
- Opus is for ambiguity, architecture, and expensive mistakes.
- Fable is for long, multi-step jobs you want to hand off.
- Using the heaviest model for everything burns credits and slows you down.
Before you send your next prompt, spend five seconds asking one question: does this task need a sprinter, an all-rounder, a specialist, or an autonomous worker? That small habit saved us more usage than any prompt trick.
Comments
Post a Comment