Claude Code Effort Levels Explained: Why Your Usage Limit Drains So Fast

Your Claude Code session eats through the 5-hour limit before lunch. Or the opposite: answers come back thin on a problem you know is hard. Both usually trace to one setting most people never open — effort.

The symptom

• The usage meter (5h / 7d) climbs much faster than it used to, with no change in how much you type.
• Or: responses arrive fast but shallow on genuinely hard debugging, and you find yourself re-prompting three times.
• Switching models didn't fix it, and you can't find a "verbosity" or "quality" slider in the docs you read.

The cause: effort is a per-turn reasoning budget

Claude Code exposes a setting called effort that controls how much reasoning the model spends on each turn. Run /effort and you get a slider labelled Faster on the left and Smarter on the right, with five stops:

low  ·  medium  ·  high  ·  xhigh  ·  max

These are the descriptions the product itself attaches to each stop:

Level	What it means
low	Quick, straightforward implementation with minimal overhead.
medium	Balanced approach with standard implementation and testing.
high	Comprehensive implementation with extensive testing and documentation.
xhigh	Deeper reasoning than high, just below maximum.
max	Maximum capability with deepest reasoning. May use excessive tokens, resulting in long response times or overthinking. Use sparingly for the hardest tasks.

Two things about this list surprise people.

First, the default is not the leftmost stop. Most current models default to high, and at least one defaults to medium. If you never touched /effort, you are probably already running near the expensive end. That alone explains a lot of "why is my limit gone" reports.

Second, the cost gap is not linear. The slider shows a relative multiplier next to each level — something like ~0.7x or ~1.6x, calculated against your current model's default. On some models the jump from high to max is modest; on others max costs several times what high does for the same conversation. Read the multiplier the slider shows for the model you are actually using instead of assuming one step up is one step of cost.

Effort is not the same as thinking

Effort tells the model how hard to think; the thinking toggle decides whether it thinks at all. They interact, and the interaction bites:

• With thinking disabled, some models cap the effort you asked for.
• Others refuse the request outright and the turn fails with an error that names the effort level.
• Modern models also scale thinking to the difficulty of the question on their own, so raising effort does not burn a fixed budget on trivial prompts — but it does remove the ceiling on hard ones, which is where "overthinking" at max comes from.

Not every model has every stop

Effort is a model capability, not a universal switch. Older models have no effort concept at all — the slider does not apply. Some mid-generation models offer low/medium/high/max with no xhigh. Only the newer families expose all five. If a level you expect is missing, that is the model, not a bug.

The procedure: set it in the right place

There are four levers, from most temporary to most permanent.

1. This session only

/effort

Pick a stop with the arrow keys. It applies to the running session.

2. This turn only

Put ultrathink in your prompt to push reasoning up for that single turn without changing the session setting. Useful when one question in ten is genuinely hard.

The far-right stop on the slider, ultracode, is not a sixth level: it is xhigh plus standing multi-agent workflow orchestration. It is session-scoped and is not persisted, so a restart clears it. You can also invoke it for a single turn by including the word ultracode in a prompt.

3. Every new session, per model

In ~/.claude/settings.json:

{
  "effortLevel": "medium",
  "modelSettings": {
    "claude-opus-5": { "effortLevel": "high" }
  }
}

effortLevel is the global default; modelSettings overrides it per model and wins. This is the fix most people actually want: keep a cheap global default, and raise it only for the model you reserve for hard work.

4. One command invocation

claude --effort medium

The verification: make effort visible

The reason this setting drains limits silently is that nothing on screen tells you what it is. Fix that: Claude Code's status line receives a JSON payload on stdin that contains an effort.level field, and the status line re-renders whenever the effort value changes.

Point statusLine at a script in ~/.claude/settings.json:

{
  "statusLine": {
    "type": "command",
    "command": "node \"%USERPROFILE%/.claude/statusline.js\""
  }
}

And read the field in that script:

const d = JSON.parse(require('fs').readFileSync(0, 'utf8') || '{}');
const parts = [];
if (d.model?.display_name) parts.push(d.model.display_name);
if (d.effort?.level)       parts.push(d.effort.level);   // low | medium | high | xhigh | max
const ctx = d.context_window?.used_percentage;
if (ctx != null) parts.push('ctx ' + Math.round(ctx) + '%');
process.stdout.write(parts.join(' · '));

Put the effort segment early in the line. Status lines are truncated from the right in narrow terminals, and a value you added specifically to keep an eye on is worthless if it is the first thing cut off.

Two more fields in the same payload are worth printing while you are there: fast_mode and thinking.enabled. Between them and effort.level you can see, at a glance, why a session is behaving the way it is.

What to actually use

Work	Level
Renames, formatting, small edits, questions with one right answer	low – medium
Ordinary feature work and bug fixes with a clear reproduction	medium
Debugging where the cause is unknown, or design decisions inside the implementation	high
Architecture calls, concurrency and race conditions, several competing hypotheses at once	xhigh
Genuinely stuck after a serious attempt	max, briefly

The practical habit: leave the global default low, raise it deliberately when a task earns it, and put the level on your status line so the choice stays visible. Most limit-burn complaints are not heavy usage — they are a high default nobody could see.