7 Choosing a Claude Model and Effort Level in Claude Code

7.1 Two Independent Decisions

When working with Claude Code, you make two decisions that together determine the quality, speed, and cost of your results: which model to use and what effort level to set. On July 7, 2026, Anthropic published a guide clarifying that these are independent decisions with different effects — and that confusing them is one of the most common sources of suboptimal results.

The core distinction:

Model selection determines the model’s fixed capability — the weights, the ceiling of what it can reason about.
Effort level determines how much work Claude does — how many files it reads, how many tools it uses, how many steps it takes before checking in with you.

Getting this distinction right matters because the fix for a disappointing result is different depending on the cause. If Claude got something wrong despite having full context, you need a more capable model. If Claude skipped reading files or running tests, you need a higher effort level.

7.2 Model Selection: Fixed Capability

A model’s capability is fixed by its training. You cannot make a smaller model reason as deeply as a larger one by prompting harder or giving it more steps — the ceiling is the ceiling. What you can do is choose the model whose ceiling matches your task’s demands.

Anthropic’s model lineup (as of mid-2026) is designed around distinct roles:

Model	Role	Analogy	Best For
Fable	Specialist	A domain expert who is the best in the world at one thing	Highly specialized tasks where depth beats breadth
Opus	Expert	A senior engineer who is excellent at everything	Complex, multi-step tasks requiring top-tier reasoning
Sonnet	Generalist	A capable all-rounder	Routine work, fast iteration, cost-effective operation

Note

The analogy is deliberate: a specialist (Fable) is the best choice when your task falls squarely in their specialty, but may be less flexible outside it. An expert (Opus) is excellent across the board. A generalist (Sonnet) handles most tasks well at lower cost and higher speed. Choose based on your task’s demands and your cost constraints.

7.2.1 When to Move Up to a Larger Model

The diagnostic rule is straightforward: if Claude got it wrong despite having full context, pick a larger model. “Full context” means Claude had access to all the relevant files, documentation, and information needed to solve the problem, read them, and still produced an incorrect or shallow result.

This indicates that the task exceeds the current model’s reasoning ceiling — more effort won’t help because the capability isn’t there. The solution is a model with a higher ceiling.

7.2.2 When a Smaller Model Suffices

Conversely, if Claude is producing high-quality results and the task is routine, a smaller model may suffice — and will be faster and cheaper. Using Opus for every task, including trivial ones, wastes capacity and budget. The discipline of matching model to task is a key part of cost-effective agent use.

7.3 Effort Level: How Much Work Claude Does

Effort level is the other half of the equation, and it’s where many users inadvertently get poor results. Effort controls how much work Claude invests before checking in with you:

How many files it reads before acting
How many tools it uses to gather information
How many steps it takes before presenting a result
How much reasoning it invests before responding

Low effort means Claude acts quickly — reads fewer files, takes fewer steps, checks in sooner. High effort means Claude is thorough — reads extensively, runs many tools, takes many steps, and invests deep reasoning.

7.3.1 When to Increase Effort

The diagnostic rule: if Claude skipped files, tests, or steps that it should have taken, pick a higher effort level. This is different from a capability problem. Claude could have read the right files or run the tests — it just didn’t invest the effort to do so.

Common symptoms of insufficient effort:

Claude made changes without reading the related code first.
Claude didn’t run the test suite after editing.
Claude presented a result without verifying it.
Claude took a shortcut when a more thorough approach was available.

7.3.2 Effort Is a General Preference

An important clarification from the guide: effort is a general preference, not a task-by-task setting. You set it once (or use a default), and it applies across your work. Tweaking effort for each individual task creates cognitive overhead without commensurate benefit.

# Set a general effort preference
effort: high  # or xhigh, medium, low, max

The recommended approach is to choose an effort level that matches your typical work, and let it apply consistently. If you find that results are consistently too shallow, raise the default. If you find that Claude is over-investing in simple tasks, lower it.

7.4 The Model-Effort Decision Matrix

Symptom	Diagnosis	Fix
Wrong result despite reading all relevant files	Capability ceiling hit	Larger model
Skipped reading files it should have read	Insufficient effort	Higher effort
Didn’t run tests after changes	Insufficient effort	Higher effort
Shallow reasoning on a complex problem	Capability ceiling hit	Larger model
Slow and expensive for simple tasks	Over-investment	Lower effort or smaller model
Good results but at high cost	Possible over-spec	Try a smaller model at same effort

Tip

When debugging a disappointing result, ask yourself: “Did Claude have what it needed and still get it wrong, or did Claude not do enough work?” The answer tells you whether to adjust the model or the effort.

7.5 Token Consumption and Cost

A nuanced point from the guide: larger models cost more per token, but they may finish in fewer steps. This means the total cost of a task isn’t simply “bigger model = more expensive.” A larger model might read fewer files (because it reasons more efficiently about which are relevant), take fewer steps (because it gets the answer right the first time), and ultimately consume fewer total tokens.

Factor	Larger Model	Higher Effort
Per-token cost	Higher	Same
Steps to completion	Potentially fewer	More
Total token consumption	Variable (may be lower)	Higher
Quality ceiling	Higher	Same (up to model ceiling)

The practical implication is that for complex tasks, a larger model at moderate effort may be more cost-effective than a smaller model at max effort — the smaller model burns tokens trying to compensate for a lower ceiling, while the larger model solves the problem efficiently.

7.6 Practical Guidance

7.6.1 Default Starting Point

For most users, the recommended starting point is:

Model: Sonnet (the generalist) for routine work; Opus for complex tasks.
Effort: high as a balanced default; xhigh for thorough work.

Adjust based on observed results using the diagnostic rules above.

7.6.2 For Cost-Sensitive Environments

If cost is the primary constraint:

Use Sonnet at medium or low effort for routine tasks.
Escalate to Opus at high effort only for tasks that genuinely need it.
Monitor token consumption and set budgets.

7.6.3 For Quality-Critical Work

If quality is the primary constraint (security reviews, critical migrations, architecture decisions):

Use Opus at xhigh or max effort.
Accept the higher per-token cost as justified by the stakes.
Use adversarial verification (Chapter 3) regardless of model/effort.

7.7 Common Pitfalls

7.7.1 Pitfall 1: Blaming the Model for an Effort Problem

A common mistake is seeing Claude skip steps and concluding “the model isn’t smart enough,” then escalating to a larger model — which also skips steps because the effort level is unchanged. The result is higher cost with no improvement. The fix is to raise effort, not switch models.

7.7.2 Pitfall 2: Blaming Effort for a Capability Problem

The reverse mistake: Claude gets a complex problem wrong despite reading everything, and the user raises effort — causing Claude to read the same files again and reason longer within the same capability ceiling, still getting it wrong. The fix is a larger model.

7.7.3 Pitfall 3: Over-Tuning Per Task

Trying to optimize model and effort for each individual task creates decision fatigue and inconsistent results. Set sensible defaults, adjust when you observe systematic issues, and resist the urge to micro-optimize.

7.8 Deep Dive: The Model Hierarchy

Understanding when to use each model requires understanding their distinct design philosophies and strengths.

7.8.1 Fable: The Specialist

Fable is designed for depth over breadth. It’s the strongest model in its specialty area, potentially exceeding Opus on tasks within that domain, but it may be less flexible outside it. Use Fable when:

Your task falls squarely within Fable’s specialty.
You need the absolute best performance in that domain.
The task is well-defined and doesn’t require broad versatility.

The specialist nature of Fable means it’s not the right default for general-purpose work. It’s a tool you reach for when the task matches its strengths.

7.8.2 Opus: The Expert

Opus is designed for excellence across the board. It’s the model that handles complex, multi-step reasoning, ambiguous requirements, and tasks that demand top-tier capability regardless of domain. Use Opus when:

The task is complex and requires deep reasoning.
Requirements are ambiguous and need judgment.
The stakes are high and quality matters more than cost.
You’re not sure which model to use — Opus is the safe choice for hard problems.

Opus is the recommended model for the hardest work: architecture decisions, complex debugging, comprehensive migrations, and security analysis.

7.8.3 Sonnet: The Generalist

Sonnet is designed for capability at scale. It handles most tasks well, at lower cost and higher speed than Opus. Use Sonnet when:

The task is routine or moderately complex.
Speed and cost matter (which is most of the time).
You’re iterating quickly and want fast feedback.
The task doesn’t require Opus-level reasoning.

Sonnet is the recommended default for day-to-day development work. Most tasks don’t need Opus’s full power, and Sonnet’s speed and cost profile make it the workhorse model.

Tip

A practical strategy: default to Sonnet, escalate to Opus. Start with Sonnet for any task. If Sonnet produces inadequate results (despite appropriate effort), escalate to Opus for that task. This optimizes for cost while ensuring quality on tasks that need it.

7.9 Deep Dive: Effort Levels

Effort levels control the thoroughness of Claude’s work. Understanding what each level actually changes helps you choose appropriately.

7.9.1 What Effort Controls

Effort is not a single knob — it influences several behaviors:

Behavior	Lower Effort	Higher Effort
Files read before acting	Fewer	More
Tools used per task	Fewer	More
Steps before checking in	Fewer	More
Reasoning depth	Shallower	Deeper
Verification before presenting	Less	More
Subagents spawned	Fewer	More

Higher effort means Claude invests more in every dimension of the work. This is why it’s more expensive but also more thorough.

7.9.2 The Effort-Quality Curve

The relationship between effort and quality is non-linear. The jump from low to high produces significant quality improvement. The jump from high to xhigh produces moderate improvement. The jump from xhigh to max produces diminishing improvement at significantly higher cost.

Quality
  ↑
  |                    ___-------
  |              __---
  |         __--
  |    _!--
  |__-
  +──────────────────────────────→ Effort
   low  medium  high  xhigh  max

This non-linear curve is why high or xhigh is recommended as the default — it captures most of the quality benefit without the diminishing returns of max.

7.9.3 When `max` Is Worth It

Despite diminishing returns, max effort is worth it for certain tasks:

Security-critical work where missing an edge case is unacceptable.
Irreversible changes (deployments, migrations) where getting it right the first time is essential.
Comprehensive audits where thoroughness is the entire point.
Hard debugging where the root cause is elusive and exhaustive investigation is needed.

For these tasks, the extra thoroughness of max — even if it produces only slightly better results — is justified by the stakes.

7.10 The Interaction Between Model and Effort

Model and effort interact in important ways:

A larger model at lower effort may outperform a smaller model at higher effort on complex tasks, because the capability ceiling matters more than thoroughness when the task is hard.
A smaller model at higher effort may outperform a larger model at lower effort on routine tasks, because thoroughness matters more than capability when the task is within reach.
Both must be sufficient. A model that’s too small can’t solve the problem regardless of effort. An effort that’s too low won’t do the work regardless of model capability.

7.10.1 A Decision Procedure

When you get a disappointing result, follow this diagnostic procedure:

Check the context: Did Claude have all the information it needed?
If no: Provide the missing context and try again.
If yes: Check whether Claude used the context (did it read the right files, run the tests?).
If Claude didn’t use available context: Raise effort. The model had what it needed but didn’t invest the work.
If Claude used the context fully and still got it wrong: Use a larger model. The task exceeds the current model’s capability.

This procedure prevents the two common pitfalls (blaming the model for an effort problem, and vice versa) by diagnosing the actual cause before adjusting.

7.11 Team-Level Considerations

For teams, model and effort decisions should be standardized rather than left to individual preference:

Set team defaults (e.g., “Sonnet/high for routine work, Opus/xhigh for complex tasks”).
Document exceptions and the reasoning behind them.
Monitor costs and adjust defaults if spending is too high.
Share learnings about which tasks need which configuration.

Standardization reduces decision fatigue and produces more consistent results across the team.

7.12 Key Takeaways

Model and effort are independent decisions. Model = fixed capability (the ceiling). Effort = how much work Claude does (files read, tools used, steps taken).
Two diagnostic rules: If Claude got it wrong despite full context → larger model. If Claude skipped steps it should have taken → higher effort.
Model roles: Fable = specialist (best in one domain), Opus = expert (excellent across the board), Sonnet = generalist (capable all-rounder).
Effort is a general preference, not a per-task setting. Set it once based on your typical work.
Larger models cost more per token but may use fewer tokens — a bigger model at moderate effort can be cheaper than a small model at max effort for complex tasks.
Avoid the two common pitfalls: don’t blame the model for an effort problem, and don’t blame effort for a capability problem.
Default starting point: Sonnet/high for routine work, Opus/xhigh for complex tasks.
Don’t micro-optimize per task. Set defaults, adjust on systematic issues.