# Models, effort and fast mode

Course: Claude Code: Pro Level — https://zero2vibecode.com/learn/claude-code-pro
Canonical URL: https://zero2vibecode.com/learn/claude-code-pro/6-3-models-effort-fast-mode
Verified against: Claude Code v2.1.292 (2026-10-15)
Last updated: 2026-10-15

A deeper look at the two dials on an answer. Which other model aliases exist and why default is not a model; where effort is set and what overrides what; why max cannot be saved in settings; and what /fast costs if you turn it on at the wrong moment.

You know the basics from the lesson on the model and effort: the model is the ceiling on capability, effort is how much work goes into an answer. Here is what comes up once you configure Claude Code seriously: which layers set the choice, what overrides what, and where extra spending hides.

## Three more aliases

Add these to `sonnet`, `opus`, `haiku` and `opusplan`:

| 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 where `opus` does not have that window |

Three important details:

- **An alias moves.** Over time it starts pointing to a newer model. If you need one specific version, write the full model name from Anthropic's models overview.
- **`default` is not a model.** `/model default` clears your choice and returns the default model for your account.
- **The provider decides.** On Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS, the same alias may lead to an older model. And depending on your plan, Fable may draw on usage credits.

## Effort: what overrides what

Effort is set in several places, and each lasts a different length of time:

| 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 is running |

Above all of them sits the `maxEffortLevel` ceiling: not even the environment variable breaks through it. `/effort auto` clears the level saved for the current model — then `effortLevel` from settings applies if it fits, otherwise the model's own level. `/effort status` shows which level is in force right now.

Fine points that catch experienced users:

- **`max` is not saved in files.** `effortLevel` and `modelSettings` do not accept it. Through `/effort` it lasts one session; permanently, only through `CLAUDE_CODE_EFFORT_LEVEL`.
- **A top-level `effortLevel` is outdated.** Set at the top level of user settings, it does not apply to the newest models. For a specific model, use `modelSettings`.
- **Models have different levels.** Ask for a level a model does not have, and you get the nearest available one below it. And `high` on one model is not the same amount of reasoning as `high` on another.
- **`ultrathink` is for one turn.** The word in a request asks for deeper thinking on that turn; the level does not change. "Think really hard" is ordinary text.
- **Ultracode is not an effort level** but a separate setting: with it, Claude plans a dynamic process for every serious task at whatever level the session is running.

An example of targeted tuning — a skill where checking matters gets its own level, independent of the session:

```yaml
---
name: five-whys
description: Finds the cause of a failure from the facts.
effort: high
---
```

While the skill is active, it runs at `high`. The `CLAUDE_CODE_EFFORT_LEVEL` variable and the ceiling still take precedence. And note: Haiku is not supported in auto mode, so a skill with `model: haiku` stays on the session's model there.

## Fast mode

`/fast` is the same Opus with an API configuration that answers faster but costs more per token. The quality is the same. The documentation calls the mode a research preview: features and prices may change.

What to know before you turn it on:

- **Opus only.** The mode works on supported Opus models; if you were on another model, `/fast` switches you to Opus. After turning it off you stay on Opus — switch back with `/model`.
- **Always usage credits.** On a subscription, fast mode 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`.
- **Turn it on at the start.** If you turn it on mid-conversation, the whole conversation up to that point is billed once at fast mode's uncached price.
- **Watch for the icon.** When the mode is on, `↯` appears next to the input.
- **Not on every provider.** It is not available on Bedrock, Google Cloud, Microsoft Foundry or Claude Platform on AWS.

Where it pays off: live debugging and fast iteration, when waiting costs more than tokens. Where it does not: long autonomous runs, CI and anything where cost matters. On Pro and Max, spending shows in the Usage credits section on claude.ai; on Team and Enterprise, through `/usage`.

And about numbers in general: `total_cost_usd` in the JSON from `claude -p` is a client-side estimate, not your bill.

**Careful.** 
Switching the model mid-session — and on most models, switching effort — makes the next request re-read the whole conversation without the cache. With /fast this hits hardest: turning it on mid-conversation bills everything so far at the uncached price in one go, and all of it from usage credits. Decide on the model, effort and fast mode before your first request.