Which Claude Model Should You Use? A Plain-English Guide to the 5 Parameters That Actually Matter
Difficulty isn't the only thing that decides which AI model to use. Here are the 5 parameters — reasoning depth, stakes, execution mode, recurrence, and cost sensitivity — plus 10 real-world use cases mapped to Haiku, Sonnet, Opus, and Fable.
Most guides about picking an AI model boil it down to one question: "how hard is the task?" That's not enough. Two tasks can feel equally "hard" and still need completely different models — because difficulty is only one piece of the decision. Here are the five things that actually determine which model you should reach for, explained in plain English, followed by ten real-world use cases across different roles.
The 5 Parameters
Reasoning Depth
How much "thinking" the task actually needs. Is there basically one right way to do it, or does it require weighing options, connecting information from different places, and catching things that aren't obvious at first glance? Ask yourself: could a smart intern with zero context do this correctly in one pass? If yes, reasoning depth is low.
Stakes
What happens if the output is wrong or mediocre? Low stakes means you notice, shrug, and fix it in two minutes. High stakes means it costs money, damages trust, or is hard to undo. Ask yourself: if this goes wrong, do I catch it instantly — or does it actually hurt me later?
Execution Mode — Single-Shot vs. Multi-Step
This is the one people confuse most. Single-shot: one input, one output — you ask, it answers, done. Multi-step: the task can't be finished in one pass. The model has to take an action, look at the result, decide what to do next based on that result, and keep going — often using tools or files — until the job is actually complete. Important distinction: multi-step does not mean "the model asks you follow-up questions." That's normal conversation and can happen with any model. Multi-step means the model is running a chain of actions largely on its own.
Recurrence
How often will you run this exact kind of task — once, or as part of a repeatable workflow you'll trigger dozens or hundreds of times? Ask yourself: is this a one-time thing, or is it going into a pipeline?
Cost Sensitivity
Independent of how often you run it — how much do you personally care about what this specific task costs to run? A one-off task can still be cost-sensitive if it involves a huge amount of input. A recurring task can be low-sensitivity if each run is high-value enough that the cost doesn't matter. Ask yourself: if this cost five times more to run, would that actually bother me?
Mapping the Parameters to Models
| Parameter | Haiku | Sonnet | Opus | Fable |
|---|---|---|---|---|
| Reasoning depth | Low | Medium–High | High | Maximum |
| Stakes | Low | Low–Medium | Medium–High | High |
| Execution mode | Single-shot | Single-shot / moderate multi-step | Sustained multi-step | Either — hardest multi-step |
| Recurrence | High | Any | Low–Medium | Rare |
| Cost sensitivity | High (you care) | Medium (balanced) | Low (you accept the cost) | Lowest (correctness over cost) |
10 Use Cases Across Different Roles
1. Content creator — batch-generating social captions and hashtags
Low reasoning depth, low stakes, single-shot, high recurrence, high cost sensitivity. → Haiku. You're producing volume, mistakes are cheap to discard, and every rupee of token cost adds up across hundreds of posts.
2. Customer support agent — answering repetitive FAQ-style tickets
Low reasoning depth, low stakes, single-shot, very high recurrence. → Haiku. Same pattern every time, fast turnaround matters more than depth.
3. Performance marketer — generating dozens of ad copy variants for A/B testing
Low-to-medium reasoning depth, low stakes (you're testing anyway), single-shot, high recurrence. → Haiku, occasionally Sonnet if the campaign angle needs sharper creative reasoning.
4. Student or researcher — summarizing a research paper into study notes
Medium reasoning depth (has to preserve meaning and structure), low-to-medium stakes, mostly single-shot, low recurrence. → Sonnet. Good balance of comprehension and cost for a task you'll do occasionally, not at scale.
5. Job seeker — tailoring a resume and running mock interview practice
Medium reasoning depth (matching your background to a role), medium stakes (this affects real outcomes), mostly single-shot with some back-and-forth, low recurrence per role. → Sonnet. Strong enough to give genuinely useful feedback without needing agentic execution.
6. Product manager — writing a full PRD from scratch
High reasoning depth (tradeoffs, edge cases, cross-functional impact), medium-to-high stakes (this document drives real work), often multi-step (draft, review gaps, revise), low recurrence. → Opus. Worth the higher cost because you're not writing PRDs every day, and a weak PRD creates expensive downstream confusion.
7. Software engineer — refactoring a multi-file codebase
High reasoning depth, medium-to-high stakes (breaking something is costly), genuinely multi-step (change code → run it → see what breaks → fix → repeat), low recurrence for any given refactor. → Opus, ideally through an agentic environment like Claude Code or Cowork where it can run the loop itself.
8. Market researcher — writing a competitor analysis report
High reasoning depth (synthesizing many sources into a coherent view), medium-to-high stakes (this informs strategy), somewhat multi-step (research, structure, revise), low recurrence. → Opus. The synthesis quality matters more than the cost here.
9. Portfolio or wealth manager — deciding an asset allocation for client money
Maximum reasoning depth, high stakes (real money, hard to undo), can be multi-step (model considers scenarios, checks assumptions), rare occurrence, low cost sensitivity. → Fable. This is exactly the 10% of cases where "good enough" isn't good enough — the cost of the model is irrelevant next to the cost of a bad allocation call.
10. Legal or compliance reviewer — reviewing a high-value contract before signing
Maximum reasoning depth (catching subtle clauses), high stakes (legally binding, expensive to get wrong), often multi-step (read, flag, cross-check terms, revise), rare occurrence. → Fable. Same logic as above: correctness matters far more than what the run costs.
Key Takeaways
Don't just ask "how hard is this?" — ask all five: reasoning depth, stakes, execution mode, recurrence, and cost sensitivity.
Multi-step doesn't mean the model asks you questions — it means the model runs a chain of actions largely on its own.
Most day-to-day work lands on Sonnet. Haiku earns its place on high-volume, low-stakes work.
Opus and Fable are for tasks where getting it right is worth paying more — the difference between them is how rare and high-stakes the task is.
Frequently Asked Questions
What's the main difference between Sonnet and Opus?
Sonnet is the balanced default for everyday single-shot or moderate multi-step work. Opus is built for sustained multi-step tasks with higher stakes — like refactoring a codebase or writing a PRD — where the extra reasoning depth and cost are worth it because you won't run the task often.
When should I use Haiku instead of a more capable model?
Use Haiku when the task is low reasoning depth, low stakes, single-shot, and high recurrence — think batch captions, FAQ responses, or ad copy variants. The value of Haiku is speed and cost efficiency at volume, not depth.
What does "multi-step" actually mean?
It means the model takes an action, observes the result, and decides what to do next on its own — often using tools or files — until the task is complete. It does not mean the model asking you clarifying questions, which can happen in a single-shot conversation with any model.
Why would I ever use Fable over Opus?
Fable is for the rare cases where correctness matters more than cost — high-stakes, maximum-reasoning-depth tasks like financial allocation decisions or legal contract review, where a mistake is expensive and hard to undo.
Enjoyed this guide?
Follow along for more practical AI tool breakdowns like this one.
Follow on Instagram →