An answer comes back wrong, and the reflex is to reach for the biggest model. Sometimes that is right. Often it is the most expensive way to fix a problem that a better request would have solved for free. Claude Code gives you two independent knobs — the model and effort — plus a fast mode on top, and each one fixes a different kind of failure.
This is the sixth post in a series on the Claude Code: Pro Level course. It draws on two lessons: model, effort and the cost of an answer and the deeper elective models, effort and fast mode.
First ask why it failed
The model is the ceiling on capability. Effort is how much work Claude puts into a request: how many files it reads, how often it checks itself, how far it goes before coming back to you. Pick the lever that matches the failure:
| What happened | What to change |
|---|---|
| Claude lacked context: a vague request, a missing tool | the context — the request, CLAUDE.md, a skill |
| Claude did not try hard enough: skipped a file, did not run the tests | higher effort |
| It had the context, it tried, and it was still wrong | a stronger model, such as opus |
| Routine work you can describe precisely | a smaller model, such as sonnet, and lower effort |
If Claude did not know your project uses its own date format, no model can guess it. That was a context problem, not a capability problem.
Model aliases
You pick a model by alias, with no version numbers to remember:
sonnet— everyday development;opus— complex reasoning;haiku— quick, simple tasks;opusplan— Opus in plan mode, then Sonnet carries out the plan.
The elective lesson adds three more:
| Alias | What it selects |
|---|---|
fable | your provider’s Fable model — for the hardest and longest tasks |
best | Fable if your account has it, otherwise Opus |
opus[1m] | Opus with a million-token window, for very long sessions |
Three details worth knowing. An alias moves: over time it points to a newer model, so if you need one exact version, use the full model name. default is not a model: /model default clears your choice and returns your account’s default. And the provider decides: on Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS, the same alias may lead to an older model.
In a session, /model opens a menu; pressing s on a row changes the model for this session only. /model sonnet with an argument remembers the choice as the default for new sessions. /model and /status both show what is set right now.
Effort: levels and layers
The levels run low, medium, high, xhigh, max. Roughly: low for quick back-and-forth where you check every result, medium for everyday work, high where edge cases are likely, xhigh deeper at a higher cost, and max for hard problems Claude solves without you — it can overthink, so check before relying on it.
To think harder about one request, write ultrathink in it. The level does not change, and it lasts that one turn. Phrases like “think really hard” are just text.
The part that catches experienced users is that effort is set in several places at once:
| Where | How long it lasts |
|---|---|
/effort <level> or the slider in /model | saved as your level for that model; s in the slider means this session only |
claude --effort <level> | this session |
CLAUDE_CODE_EFFORT_LEVEL | every session started with it; overrides all other sources |
modelSettings or effortLevel in a settings file | every session the file applies to |
effort: in a skill’s or subagent’s frontmatter | while that skill or subagent runs |
Above all of them sits the maxEffortLevel ceiling; not even the environment variable breaks through it. /effort status tells you which level is in force right now.
A few fine points from the lesson:
maxis not saved in files.effortLevelandmodelSettingsdo not accept it. Via/effortit lasts one session; permanently, only throughCLAUDE_CODE_EFFORT_LEVEL.- A top-level
effortLevelis outdated. In user settings it does not apply to the newest models; usemodelSettingsfor a specific model. - Levels differ between models. Ask for one a model lacks and you get the nearest one below it, and
highon one model is not the same amount of reasoning ashighon another.
Fast mode: the same Opus, faster and pricier
/fast keeps the same Opus model and the same quality but uses an API configuration that answers faster and costs more per token. The documentation calls it a research preview, so features and prices may change.
- Opus only. If you were on another model,
/fastswitches you to Opus, and you stay there after turning it off. - Always usage credits. On a subscription it is paid only from extra usage credits, even if your plan’s limit is not used up. Without credits enabled,
/fastanswersFast mode requires usage credits. - The
↯icon next to the input tells you it is on. - Not on every provider: it is unavailable on Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS.
It pays off in live debugging and fast iteration, when waiting costs more than tokens. It does not pay off in long autonomous runs, CI, or anything where cost matters.
The real trap: switching mid-conversation
Changing the model mid-session — and on most models, changing effort too — makes the next request re-read the whole conversation without the cache, which is slower and more expensive; that is why Claude Code asks you to confirm. With /fast it hits hardest: turning it on mid-conversation bills everything so far at the uncached price in one go, all from usage credits. Decide on model, effort and fast mode before your first request.
A short recipe
- Answer failed? Diagnose first: context, effort or capability.
- Choose the model and effort at the start of the task, not halfway through.
- For unattended work, pick the cheaper model on purpose. The dev containers post runs its one unattended job with
--model sonnet --max-turns 10, and the workflows post notes that workflow agents run on the session’s model unless something else sets it. - Keep
/fastfor live debugging, switched on before the first message. - Numbers like
total_cost_usdin the JSON fromclaude -pare a client-side estimate, not your bill.
Frequently asked questions
What is the difference between the model and effort?
The model is the ceiling on how capable an answer can be. Effort is how much work Claude puts into reaching it: how much it reads, how often it checks itself.
How do I make max effort permanent?
Only through the CLAUDE_CODE_EFFORT_LEVEL environment variable. Settings files do not accept max, and /effort max lasts one session.
Why is /fast so expensive when I turn it on mid-conversation?
Turning it on mid-conversation bills the whole conversation so far once at fast mode’s uncached price, from usage credits. Turn it on at the start of a session instead.
Where to dig deeper
Start with model, effort and the cost of an answer for the diagnosis habit, then the elective models, effort and fast mode for the layering and the fast-mode fine print.