Stop defaulting to Opus. Haiku is enough 70% of the time.

I see a lot of devs who systematically send everything to Claude Opus 4.7. “It’s the biggest model, it’s the best.” Except on 70% of their tasks, Haiku 4.5 would do the same job for 25 times cheaper.

I spent a month measuring this properly. Here’s what I found.

The setup

For 4 weeks, I systematically ran my tasks in parallel across the three current Claude models:

• Haiku 4.5 (released October 2025) — small model, fast, cheap
• Sonnet 4.6 — balanced, general use
• Opus 4.7 — big model, deep reasoning

The tasks came from my actual daily usage, sorted into 8 categories. I compared the outputs qualitatively and scored all three models on each task. Quick reminder of the approximate prices at the time of writing (in USD/million tokens):

Model	Input	Output
Haiku 4.5	$0.80	$4
Sonnet 4.6	$3	$15
Opus 4.7	$15	$75

Opus costs 19x more than Haiku on input, 19x on output. If Haiku does the same job, that question deserves a serious answer.

Results by category

Tasks where Haiku is enough (70% of my volume)

Classification and tagging. Sorting documents, labeling emails, categorizing leads. Haiku does just as well as Opus on 500 tested items (Haiku accuracy 97.8% vs Opus 98.2% — not a significant gap).

Structured data extraction. Parsing JSON out of text, extracting entities, formatting. Haiku is excellent, especially when the output schema is well defined.

Short summarization. Summarizing an article, an email, a doc page into 3 bullet points. Haiku gives drier summaries, sometimes better than Opus, which tends to ramble.

Simple translations (FR ↔ EN on non-literary technical content). Equivalent quality, Haiku 20x faster.

Simple code modifications. Renaming a variable in a file, adding a type, reformatting a chunk of code. Haiku handles this very well when the scope is well defined.

Tasks where Sonnet is the sweet spot (25% of my volume)

Medium-complexity code review. Haiku misses subtleties, Opus is overkill. Sonnet 4.6 hits the right level — it catches bugs without over-interpreting.

Writing technical articles (like this one). Sonnet has the right mix of structure and tone. Opus is too “wise,” Haiku too “flat.”

Refactoring functions. When the logic requires understanding intent and then restructuring. Sonnet handles it, Haiku trips on edge cases.

Debugging with a clear stack trace. Sonnet finds the root cause in 2 turns, Opus also finds it but takes 3x longer and costs 5x more.

Tasks where Opus wins (5% of my volume)

System-level architecture. Designing a microservices structure, choosing between CQRS and event sourcing for a specific use case. Opus sees trade-offs that Sonnet misses.

Multi-layer debugging (front → back → DB → cache). When a bug propagates through a system, Opus holds the global context in memory better.

Math / abstract reasoning (rare in my usage, but when it comes up, Opus is the only one that holds up).

Large-scope refactoring (more than 10 files impacted). Opus keeps things more coherent across the whole set.

The decision table

I consolidated this into a simple tree I now follow:

Task to do → ask 3 questions:

1. Is there a clear output schema?
   (classification, extraction, precise format)
   → YES: Haiku

2. Does it require judgment on nuanced content?
   (review, writing, medium refactoring)
   → YES: Sonnet

3. Does it require system-level or multi-layer reasoning?
   (architecture, complex debugging, large refactor)
   → YES: Opus

If you're torn between two, pick the smaller one.
You can always re-run on the bigger one if the result doesn't hold up.

What I saved

Before this month of testing, 80% of my API usage went through Opus “by default.” After, my mix is 60% Haiku, 30% Sonnet, 10% Opus.

Impact on my bill: -62% at constant request volume.

Impact on perceived quality: neutral. I didn’t feel any degradation on my use cases. The few times I was disappointed by Haiku, I re-ran on Sonnet and it was fine. Twice I went all the way up to Opus.

The “might as well” argument

The classic counter-argument: “why bother, Opus works everywhere, I pay $200/month, I can absorb it.”

Two answers to that:

1. Time. Haiku is ~5x lower latency than Opus. On interactive tasks (REPL, small agent), that changes the experience. Waiting 8 seconds for a classification is ridiculous.

2. Scale. If you’re building a product that uses Claude at volume, the cost ratio becomes structural. You can’t sell a $19/month SaaS that routes every request through Opus at $0.30 a call. The margin isn’t there.

Takeaway

Haiku 4.5 is underrated. It crossed a quality threshold in late 2025 that gets overlooked because we equate “small model” with “dumb model.”

Opus isn’t “the best at everything.” It’s the best when you actually need what it’s built for: heavy reasoning, extended context, long-range coherence.

The “big model by default” reflex is bad. It costs a lot without improving results on most tasks. Get in the habit of starting small and only scaling up if the result doesn’t hold.

If you use Claude seriously, spend a day running this same benchmark on your own use cases. You’ll probably cut your bill by half or a third, without losing quality. It’s the best possible ROI for a day of work.