Claude Code lets you pick how hard the model thinks before it acts: medium, high, xhigh or max. Max sounds like the safe choice for anything that matters, and it's the level that uses the most tokens.
Usage limits weren't my concern. I'm on Claude's $200-a-month plan and had plenty of usage left over. What I wanted to know was whether all that extra thinking got me better results.
So instead of going on feel, I went through my own transcripts to see what each level actually bought me.
The short version: max was a fifth of my prompts and about half of everything Claude generated for me. Its work took longer, and I had to step in just as often as with xhigh. I couldn't find anything max bought me that xhigh didn't.
What I measured
Claude Code keeps every session as a JSON Lines file under ~/.claude/projects. Each model request in it records the effort level and how many tokens it generated. I wrote a small Python script that reads those files and prints totals, without printing any prompts, code or file names.
A prompt here is a message I typed, plus all the work Claude did until my next message. I left out sessions that my project agents run on my Mac, since another Claude picked the effort there, along with background job notices and scheduled runs. That left 1,037 prompts across 161 sessions from September 23 to November 8, 2026, nearly all in the Claude desktop app and 87% on Opus 5.5.
The script sorts each prompt by the tools Claude used: questions (no tools), exploration (reading and searching), shell and tests (commands but no edits), small edits (one file, 30 lines or fewer), larger changes, debugging (prompts that mention a bug, an error or a fix) and delegation to subagents.
There's no ground truth for “the code was right,” so I used two stand-ins:
- I stepped in: I interrupted Claude, or my next message read like a correction (“still broken,” “that's wrong,” “revert”).
- Clean finish: I didn't step in, and Claude didn't have to edit the same file again after running a command.
What each level cost and returned
| Effort | medium | high | xhigh | max |
|---|---|---|---|---|
| Prompts | 292 | 315 | 220 | 210 |
| Median tokens | 1.6k | 2.9k | 8.9k | 14.6k |
| Median time | 29 s | 56 s | 2.6 min | 4.2 min |
| I stepped in | 4.5% | 6.7% | 5.0% | 5.2% |
| Clean finish | 95% | 91% | 91% | 85% |
Tokens are generated tokens per prompt, thinking included. Medium includes 121 prompts on Sonnet. The 95% ranges for clean finish are 92–97% (medium), 88–94% (high), 86–94% (xhigh) and 80–89% (max).
For a typical prompt, max generated 1.6 times as many tokens as xhigh, and about twice as many on average. Most of the extra was thinking: a median of 8.7k thinking tokens per prompt against 3.8k. A typical max prompt also took 4.2 minutes against 2.6.
What it didn't do was save me any corrections. I stepped in on 5.2% of max prompts and 5.0% of xhigh prompts. Its clean-finish rate was lower, 85% against 91%.
Same kind of work
Each level got a different mix of work, so the fairer comparison is within one kind. These are the three kinds where both levels have enough prompts:
| Work | xhigh | max | Max tokens vs xhigh |
|---|---|---|---|
| Shell and tests | 96% of 112 | 95% of 105 | 1.5× |
| Small edits | 94% of 16 | 82% of 17 | 1.5× |
| Larger changes | 82% of 51 | 69% of 64 | 2.6× |
On larger changes, max finished cleanly 69% of the time against 82% for xhigh, while generating 2.6 times the tokens. That gap isn't statistically solid (p = 0.13), and max's larger changes were bigger: a median of 155 lines written against 28.
Matched on size, it's closer to a tie. For changes of 31 to 100 lines, xhigh finished cleanly 35 of 39 times and max 25 of 28. On the biggest changes, over 300 lines, max went 9 for 19 and xhigh 0 for 3, which is too few to say anything.
Why max's clean finishes dropped
Of max's 31 misses, 22 included a retry: Claude edited a file, ran something and edited the same file again. That's also what a careful test-and-fix loop looks like, so I don't read the lower clean-finish rate as max doing worse work. The number I trust more is how often I had to step in, and that was the same.
What this can't tell me
- Max mostly came from two days. 158 of my 210 max prompts were on October 15 and 16, across 26 sessions in total. The results could say more about what I was building that week than about max.
- I chose the effort level. I probably reached for max when a task already looked hard. Comparing within the same kind of work helps, and so do the 9 sessions where I used both (max finished cleanly 83% of the time, xhigh 93%), but neither removes it.
- The p-values are optimistic. Prompts in the same session aren't independent of each other.
- Corrections are matched by phrases. A polite “could you also handle this case” isn't counted, and a message that only mentions an error might be.
- It's one person. About six weeks of my own work, mostly on Opus 5.5. Subagent work, 23.9 million generated tokens, isn't in the tables.
What I'm doing now
- xhigh for larger changes. High finished them cleanly only 72% of the time.
- high for small edits and shell work, where it finished about as cleanly as xhigh with less than half the tokens.
- medium for quick questions.
- max when xhigh gets stuck, not as a default.
My own max use had already dropped to 11 prompts in the three weeks after October 17. Now I have numbers to keep it there.
Run it on your own logs
The script is one Python file with no dependencies: effort_feedback.py. It only reads files, and it prints totals, never prompts or code. Run python3 effort_feedback.py --typed-only --details to get the tables above for your own history. Claude Code can delete transcripts older than 30 days (the cleanupPeriodDays setting), so raise that first if you want a longer look back.
Max is still there for the hard days. It just isn't my default anymore.