Claude Opus 5 gives you five effort levels: low, medium, high, xhigh, max. In Claude Code you set them with /effort. Max sounds like the one you want – the biggest number, the deepest thinking, the model with the handbrake off. So that is what you pick for the hard Delphi refactoring, right?
No. For coding, pick xhigh. Max effort scores lower than xhigh on two of the three agentic coding benchmarks Anthropic published, and costs 12-15% more. The proof comes from Anthropic themselves.
The chart nobody reads
The Opus 5 release page has three charts titled “Agentic coding by effort level”. Cost per task on the horizontal axis (log scale, dollars), score on the vertical, and one dot per effort level – five dots per model, low on the left through max on the right.
Look at where the Opus 5 line ends. On two of the three charts it goes down on the last dot. The model scores worse at max than at xhigh, and you pay more for the privilege.
Anthropic prints no numbers on those charts, so I measured the dots against the axes and redrew the whole effort ladder:
Figure: Opus 5’s five effort levels on the three coding benchmarks Anthropic published. Solid black is where effort still buys you something. The dashed step from xhigh to max goes down on two of the three.
| Effort | Frontier-Bench v0.1 | AA Coding Agent Index | CursorBench |
|---|---|---|---|
| high | 39.4% at $11.66 | 65.2 at $6.48 | 66.7 at $3.90 |
| xhigh | 44.3% at $14.33 | 66.7 at $8.24 | 69.3 at $7.31 |
| max | 43.2% at $16.52 | 64.8 at $9.20 | 70.0 at $8.18 |
Two benchmarks out of three: max scores lower and costs more. On Frontier-Bench it drops about a point while costing 15% more. On the Artificial Analysis Coding Agent Index it drops almost two points while costing 12% more. On CursorBench max does win – by 0.7 of a point, for 12% more money. That is the best case for max, and it is still a bad deal.
This is new with Opus 5
Here is the part that convinced me it is a real effect and not chart noise. Those same three charts also plot Opus 4.8 and Fable 5, so I measured their ladders too. The last step, xhigh to max:
| xhigh → max | Frontier-Bench | AA Coding Index | CursorBench |
|---|---|---|---|
| Opus 5 | -1.0 | -1.9 | +0.7 |
| Opus 4.8 | +3.2 | +2.0 | +2.7 |
| Fable 5 | +2.1 | (not readable) | +2.0 |
On Opus 4.8 and Fable 5, max is the top of the ladder every single time, and it earns a solid two to three points for the money. Opus 5 is the first model where the top rung goes backwards on coding. (On the AA chart two of Fable’s five dots overlap, so I could only separate four of them – but that sequence rises the whole way and ends on its highest point, so there is no dip there either.)
That matters for anyone upgrading. If you carried your effort setting across from Opus 4.8 – the model I benchmarked against Fable 5 on Delphi code reviews – where max was genuinely the best coding setting, you are now paying more for less. Anthropic tells you this in the migration notes – “run a fresh effort sweep on your evals rather than reusing them” – and this is exactly why.
Anthropic says it out loud too
You do not have to trust my pixel-measuring. The Claude Code documentation has a table telling you when to use each level, and the max row says: “Can improve performance on demanding tasks but may show diminishing returns and is prone to overthinking. Test before adopting broadly.”
Prone to overthinking. That is Anthropic’s word for it, in Anthropic’s own manual.
Where max is genuinely better
Now the other side, because the picture is not one-sided. Anthropic’s platform docs say Opus 5 converts extra effort into better results “up to the max level”, and on the non-coding evaluations max really is top of the pile – Artificial Analysis has Opus 5 at max leading their Intelligence Index and their agentic knowledge-work benchmark. Anthropic’s own recommendation is to start at high, step up to xhigh for demanding coding and agentic work, and go to max “when a task justifies unconstrained token spending”.
So max is not broken. It is aimed at deep open-ended reasoning, not at coding.
And here is the honest caveat, because I do not want to oversell a pixel measurement. The Frontier-Bench dip is roughly one point on a mean of five attempts per task (Anthropic’s own footnote). One point on five runs is close to noise. I would not claim “max makes Claude dumber”. I claim the smaller, safer thing: on coding work you pay 12-15% more for no gain you can rely on.
What this means for Delphi
Our work is the structured kind – refactor this unit, find why this DFM binding broke, port this to 64-bit, hunt this access violation. It is the same daily loop I described in Trying out Claude Code for Delphi. It is not open-ended research. That is exactly the shape of task where overthinking bites: the model second-guesses a correct plan, wanders off, and burns your window doing it.
And your window is the real currency here. Those dollar figures come from Anthropic’s benchmark harness. On a Pro or Max subscription you never pay per task – you pay in tokens against that rolling 5-hour bucket, and max effort empties it faster for no gain.
The conclusion: two settings, that is all
Before anything else, the obvious wrong lesson: “xhigh for Delphi, max for everything else.” That is not it.
The line is not Delphi versus the rest. It is tool-driven work versus pure thinking. Every chart above is an agentic coding benchmark – the model reading files, running commands, editing, checking its work in a loop. That is where max overthinks and loses. Take the tools away, ask for hard reasoning on its own, and max is the best there is – as the knowledge-work scores above already showed.
So here is the rule, and it is only two lines long.
Is Claude going to touch a file? Use xhigh. Refactor a unit, hunt an access violation, port to 64-bit, review a legacy project, write the tests. Anything with an agentic loop in it. This is exactly what the three charts measure, and xhigh is the top of that curve.
Is it a question? Use max. No code, no files, no tool loop – just hard thinking. Which of these three architectures will I regret least in five years. Is this plan sound. Where is the hole in this argument. Open-ended problems with nothing to compile and no test to run. Max is measurably the best thing available for that, and the effort ladder on those evaluations spans 407 Elo points from low to max – a far bigger spread than anything in the coding charts.
That is the whole answer. Programming, xhigh. Thinking, max.
The boundary is fuzzier than those two lines suggest, so here is the test that actually works: ask where the hard part is. If the hard part is the doing – many steps, many files, many tool calls, and each step is not that clever on its own – that is xhigh. If the hard part is the thinking and the output is a couple of paragraphs of judgement, that is max. Writing a book chapter with Claude looks like “not programming”, but it is file after file and search after search, so it is xhigh. Asking Claude whether an argument holds up is three sentences of output and all of the difficulty up front, so it is max.
Two footnotes and then we are done. If you are on a smaller plan, drop to medium for mechanical work – renaming, formatting, a quick lookup. Opus 5’s medium is much stronger than medium on any older Opus, and Anthropic explicitly tells you to use the lower levels as your main cost control rather than living at the top of the ladder.
And if you ever wondered what the ultracode entry in the /effort menu actually sends to the model: xhigh. Not max. Even Anthropic’s own “turn everything up” button stops one rung short.
claude --effort xhigh // the Delphi session claude --effort max // the thinking session
Or /effort xhigh inside a running session – see also my list of useful console commands for Claude Code. One warning if you put it in a settings file: "effortLevel": "max" is not accepted there – the docs say max and ultracode are session-only. The environment variable CLAUDE_CODE_EFFORT_LEVEL=max is the one channel that does make max stick.
Sources
- Charts + footnote: anthropic.com/news/claude-opus-5 (“Agentic coding by effort level”; Frontier-Bench footnote: “mean reward over 5 attempts per task”, mini-SWE-agent harness). The values in my tables were measured from the chart images by pixel position against the calibrated axes – Anthropic prints no numbers.
- Max is “prone to overthinking” / diminishing returns, effort persistence,
effortLevelrejectingmax, ultracode = xhigh: code.claude.com/docs/en/model-config - Opus 5 effort recommendation (“start with high”, step up to xhigh / max): platform.claude.com/docs/en/build-with-claude/effort
- “converting additional effort (up to the max level) into better results”: platform.claude.com/docs/en/about-claude/models/whats-new-opus-5
- Max leads the non-coding indexes (Intelligence Index 61, GDPval-AA v2 1861 Elo, AA-Briefcase 1720 Elo, all at max effort): artificialanalysis.ai/articles/opus-5
This piece started life as a subchapter of “Delphi in all its glory” book 5 – AI-assisted development for Delphi, in the chapter about dialling the model with /model and /effort.
Has anyone else measured this on real Delphi work rather than benchmarks? I am curious whether the dip shows up on legacy VCL refactoring, which is a much messier job than anything in these test suites. Leave a comment below.