# Claude Code models, effort and fast mode: which knob to turn, and when

Canonical URL: https://zero2vibecode.com/blog/claude-code-models-effort-fast-mode
Date: 2026-10-21
Tags: claude-code, models

The model sets how capable an answer can be; effort sets how much work goes into it. Before you turn either, work out why the answer failed. Then: the model aliases, which effort setting overrides which, and what /fast costs if you switch it on at the wrong moment.

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](https://zero2vibecode.com/learn/claude-code-pro) course. It draws on two lessons: [model, effort and the cost of an answer](https://zero2vibecode.com/learn/claude-code-pro/1-4-model-and-effort) and the deeper elective [models, effort and fast mode](https://zero2vibecode.com/learn/claude-code-pro/6-3-models-effort-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:

- **`max` is not saved in files.** `effortLevel` and `modelSettings` do not accept it. Via `/effort` it lasts one session; permanently, only through `CLAUDE_CODE_EFFORT_LEVEL`.
- **A top-level `effortLevel` is outdated.** In user settings it does not apply to the newest models; use `modelSettings` for a specific model.
- **Levels differ between models.** Ask for one a model lacks and you get the nearest one below it, and `high` on one model is not the same amount of reasoning as `high` on 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, `/fast` switches 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, `/fast` answers `Fast 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

1. Answer failed? Diagnose first: context, effort or capability.
2. Choose the model and effort at the start of the task, not halfway through.
3. For unattended work, pick the cheaper model on purpose. The [dev containers post](https://zero2vibecode.com/blog/claude-code-dev-containers) runs its one unattended job with `--model sonnet --max-turns 10`, and the [workflows post](https://zero2vibecode.com/blog/subagents-workflows-agent-teams) notes that workflow agents run on the session's model unless something else sets it.
4. Keep `/fast` for live debugging, switched on before the first message.
5. Numbers like `total_cost_usd` in the JSON from `claude -p` are 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](https://zero2vibecode.com/learn/claude-code-pro/1-4-model-and-effort) for the diagnosis habit, then the elective [models, effort and fast mode](https://zero2vibecode.com/learn/claude-code-pro/6-3-models-effort-fast-mode) for the layering and the fast-mode fine print.