The Vibe Father
Claude Opus 5 is available in Claude Code from launch day, July 24, 2026. If your model picker does not show it, you need to update the CLI — that is why "update claude code" and "claude code update" both went breakout in US searches within hours of the release.
This is the practical setup guide, updating, selecting the model, choosing an effort level, setting max_tokens so xhigh and max actually have room to work, and deciding whether fast mode earns its 2x rate. For the cost model behind these choices, see the pricing and effort-level guide.
Update first
New models ship server-side, but the model picker, the effort ladder and the config flags live in the client. An out-of-date CLI is the single most common reason Opus 5 does not appear.
Update through whichever channel you installed with, then restart the session — a running session holds its model list in memory. Check the Claude Code docs for the current command for your install method rather than trusting a command copied from a blog post written for an older release.
| Symptom | Most likely cause |
|---|---|
| Opus 5 missing from the picker | CLI out of date — update and restart |
| Model listed but errors on use | Plan or workspace lacks access |
/effort not recognised | Client predates the effort ladder |
| Answers truncate at xhigh or max | max_tokens too low for the thinking budget |
| Everything feels very slow | Effort left at max — that is the benchmark setting |
Selecting the model
Claude Opus 5's public model identifier is claude-opus-5. In an interactive Claude Code session you switch models from the model picker, for scripted or CI use, set it in your model configuration so runs are reproducible rather than inheriting whatever the last interactive session selected.
Opus 5 is the default on Claude Max and the most capable model available on Claude Pro. If you are on a team plan, model availability can be governed by workspace policy, so a missing model is not always a client problem.
The effort ladder is the setting that matters
Opus 5 supports the full ladder low, medium, high, xhigh, and max, with max as the explicit top tier for the deepest reasoning.
Illustrative shape, not measured values, reasoning spend climbs steeply across the ladder while quality gains flatten. Reporting notes max occasionally scores below xhigh on some benchmarks while costing more.
In an interactive session, /effort switches level, and the choice persists across sessions. For a non-interactive or scripted run, pass --effort at launch so the run does not silently inherit a previous setting.
| Effort | Use it for | Avoid it for |
|---|---|---|
| low | Renames, formatting, mechanical edits | Anything with a design decision |
| medium | Small features with clear tests | Cross-service changes |
| high | Most real agent work — the sane default | Trivial edits |
| xhigh | Hard debugging, migrations, high-autonomy runs | Anything a human waits on |
| max | Genuinely stuck problems | Default routing |
The guidance for coding and high-autonomy work is xhigh, max exists for the hardest cases. Almost nobody should run max as a global default, and the reason is not only cost — it is that the quality curve flattens while latency does not.
Set max_tokens properly at xhigh and max
This is the mistake that produces the most confusing symptom. At xhigh or max effort the model spends a large number of tokens thinking before it acts. If max_tokens is tuned for a lower tier, the model runs out of room mid-task — you see truncated output, abandoned tool calls, or an agent that appears to give up halfway through a subagent chain.
When running at xhigh or max, set a large max_tokens so the model has room to think and act across subagents and tool calls. If raising effort made results worse, check this before you conclude the effort setting is broken.
Fast mode, when 2x the rate is worth it
Fast mode delivers roughly 2.5x the output speed at twice the base rate — effectively about $10/$50 per million tokens against the standard $5/$25.
| Scenario | Fast mode? | Reason |
|---|---|---|
| You are sitting there waiting | Yes | Your time costs more than the tokens |
| Pairing or live demo | Yes | Latency is the felt quality |
| Overnight ticket queue | No | Nobody is waiting |
| CI check with a generous budget | Usually no | Default speed fits the window |
| Agent is slow due to bad retrieval | No | You would pay to go fast in the wrong direction |
Fast mode buys latency, not quality. If your session feels slow because the agent re-reads half the repository every turn, fast mode just burns the budget quicker. Fix the context first. The diagnostic is simple, look at how many input tokens a typical turn consumes. If that number is large and roughly constant regardless of the task, you have a retrieval problem, and no amount of extra speed will make the answers better or the bill smaller.
The 1M context window is a ceiling, not a target
Opus 5 carries a 1M token context window, and the most expensive habit you can pick up on launch day is trying to use it. Claude Code will happily read a great deal of your repository into context if you let it, and you pay input rates for every token on every turn.
| Habit | Effect on cost | Effect on quality |
|---|---|---|
| Dumping the repo into context | Large increase every turn | Usually worse — relevant signal gets diluted |
| Targeted file reads | Small | Better — the model sees what matters |
| Caching stable context | Large decrease | Neutral |
| Summarising tool output | Moderate decrease | Often better — less noise |
The rule that holds up, send the smallest context that contains the answer. A bigger window means you are less likely to hit a hard wall mid-task, not that you should aim for it. Prompt caching on stable content — your system prompt, coding standards, repository map — is usually the single largest saving available in a Claude Code setup, and it costs nothing in quality.
One caching caveat that quietly breaks the saving, caches only hit when the beginning of the prompt is byte-identical between calls. If anything volatile sits at the top — a timestamp, a run ID, a reordered tool list — you lose the cache without any error message. Keep volatile content at the end.
Subagents, persistence, and knowing when to stop
At xhigh and max effort Opus 5 will spawn and coordinate work across subagents and tool calls, and it will keep going through failures rather than returning early. That is the behaviour you are paying for, and it needs a boundary.
The failure mode is not the model producing bad code. It is the model producing a long, expensive, plausible-looking exploration of a badly specified problem. Every guardrail below exists to convert persistence into progress
| Guardrail | What it prevents |
|---|---|
| A failing test as the goal | Ambiguity about what "done" means |
| Token ceiling per task | Unbounded self-retry loops |
| Wall-clock timeout | A task quietly consuming an entire queue slot |
| Bounded file scope | Refactors that sprawl beyond the ticket |
| Human gate on destructive actions | Confident output touching production |
If you take one habit from this section, give the agent a definition of done it can verify itself. "Make this test pass without changing the test" is a better prompt than three paragraphs of description, and it converts a persistent model from an expense into leverage.
A sensible starting configuration
- Update the CLI and restart. Confirm
claude-opus-5appears in the picker. - Set effort to high as your default. This is the production setting, not max.
- Raise
max_tokensbefore you experiment with xhigh or max. - Pin the model in project config so CI and teammates get the same behaviour.
- Use xhigh deliberately — a specific hard ticket, not a global switch.
- Leave fast mode off until you have a surface where a human is genuinely blocked.
- Keep a cheaper model configured for mechanical work and escalate on failure.
Cost guardrails worth setting on day one
A more capable model at the same price is not automatically a cheaper month. Reasoning models spend tokens thinking, and the effort ladder makes that spend a choice you can get wrong quietly.
| Guardrail | Why set it now |
|---|---|
| Effort mapped to task type | Stops max-effort becoming the accidental global default |
| Prompt caching on stable context | Usually the largest single saving in a Claude Code setup |
| Retry cap with human escalation | Unbounded loops are how a small bill becomes a large one |
| Monthly ceiling with alerts at 60% and 85% | You want to find out on the 12th, not the 30th |
| Cheap model for mechanical work | A large share of tasks never needed a frontier model |
The ordering matters. Caching and context discipline are free — no quality risk at all. Effort right-sizing carries a small risk on the tasks you downgrade, so measure it. Switching the frontier model is the highest-disruption lever and usually the smallest saving of the three, even though it is the one launch week is talking about.
What changes about how you drive the agent
Opus 5's headline behavioural trait is persistence — it keeps working rather than returning a plausible partial answer. In Claude Code that changes what a good prompt looks like.
A persistent model given a vague goal will explore for a long time and bill you for it. A persistent model given a clear definition of done — a failing test to make pass, a specific acceptance criterion, a bounded file set — will use that persistence productively. The single highest-leverage change most people can make after switching is writing sharper task definitions, not tuning the model.
| Harness control | Why it matters more with Opus 5 |
|---|---|
| Explicit success criteria | Persistence needs a finish line |
| Token ceiling per task | The hard stop on a self-retrying loop |
| Wall-clock timeout | A persistent model will use every second given |
| Test gate before merge | Confident output still needs mechanical verification |
| Scoped credentials | Unchanged best practice, more agent autonomy |
Common questions
How do I update Claude Code?
Update through the channel you installed with, then restart the session so the model list refreshes. Check the official Claude Code docs for the current command rather than an older blog snippet.
Why can I not see Opus 5 in Claude Code?
Almost always an out-of-date client. If updating does not fix it, check whether your plan or workspace policy grants access to the model.
What effort level should I use in Claude Code?
High as a default, xhigh for coding and high-autonomy work, max only for genuinely stuck problems. Use /effort interactively or --effort at launch.
Why did xhigh make my results worse?
Usually max_tokens is too low, so the model runs out of room mid-task. Raise it before changing anything else.
Is fast mode worth it?
Only when a human is blocked. It is 2.5x the speed at twice the rate and does not improve quality.
Does the effort setting persist between sessions?
Yes — an effort level chosen in an interactive session persists. That is convenient and it is also how teams end up running max effort for weeks without noticing. For scripted and CI runs, pass --effort explicitly so the run never inherits someone's leftover interactive choice.
Should I use the 1M context window?
Only as far as your task genuinely needs. It is a ceiling that stops you hitting a wall, not a target. Targeted reads plus caching beat large context on both cost and quality.
Sources and further reading
- Claude Code docs, model configuration
- Claude Platform docs, effort
- Claude Platform docs, what's new in Opus 5
- Anthropic. Introducing Claude Opus 5
- Running agents inside a controlled harness
A last note on why the update question trends every single launch. Model availability is server-side, but the controls are client-side, and the gap between "the model exists" and "your tool can drive it properly" is where most of the launch-day frustration lives. Updating takes a minute. Working out that your truncated outputs were a max_tokens problem rather than a model problem can take an afternoon — so check the boring things first, in the order above, before you conclude the new model is worse than the old one.
