Working with Claude Opus 4.8 — a step-by-step guide · Resource

This is the version to keep at hand when you move from Opus 4.7 to 4.8. Open it the first time you launch the new model, so you set it up right from the start instead of running on the defaults. Each step says what you do and what you should see; setting and command names are copied verbatim.

The rule in one line: pick the effort level for the task first, then write instructions positively and with a reason attached — those are the two levers that move the needle most.

Before you start — what carries over unchanged

Some of what you know from 4.7 carries over to 4.8 with no action from you. Worth knowing, so you don't go hunting for settings that don't exist.

Context window — 1 million tokens. That's how much text the model "sees" at once: instructions, files, prior conversation. A large project fits inside it.
Price — input and output (the text you send, and the text the model returns) cost the same as they did in 4.7.
Session limits — the five-hour window and the weekly caps stay as they were.
Claude Code request limits over the API — raised, to make room for the higher token use at the stronger effort levels. This applies to the technical limits for API users.

An honest note before you start: not every problem you had with 4.7 was the model's fault. Before you blame the tool, check whether it's the way you're using it — often it is.

Step 1: Set the effort level

This is the single most important lever today. Effort level is the setting that controls how much "effort" the model puts into a task.

In Claude Code, type:

effort

A slider appears. It defaults to high. The available levels:

low, medium, high, x-high, max, ultracode

ultracode is x-high combined with the workflows feature.

How to read the scale:

Higher — the model gets "smarter", but costs more in tokens.
Lower — faster answers.

It's a balance between model intelligence, token cost, and speed. Match the level to the task:

Task needs real work and the model sits on low or medium → that's just not enough effort, raise it.
Task is trivial and the model sits on x-high → it can overthink, second-guess, and complicate something simple, so bring it down.

What you should see: typing effort brings up a slider with the current level. If you're someone who opens Claude Code and never touches this setting, start now. The gap between low and x-high can be big enough to feel like a completely different model.

Step 2: Write what the model should do, not what it shouldn't

One thing stands out in the good examples in the documentation: they rarely tell the model what not to do. They almost always state directly what to do. The model handles a positive instruction better than a list of prohibitions.

It's a simple habit change:

Instead of building a long list of "don't do this, don't do that"
Write the outcome you actually want

What you should see: the model reads your intent more accurately, instead of picking its way around a list of bans.

Step 3: Add the "why" behind an instruction

This builds on step 2. The model behaves as if it's curious about context — tell it to avoid something and it more or less asks "but why?". The more context you give it, the better it sticks to the instruction.

Compare two versions of the same instruction:

don't use em dashes

I want this to read like I wrote it myself; it's my style
and I never use em dashes, so stick to that.

Same instruction, but the second one comes with a reason — and the model visibly sticks to it more willingly.

What you should see: fewer negative instructions, more "why" context → the model holds to your rules better.

Step 4: Watch when the model reasons and when it reaches for tools

By default, Opus 4.8 reasons first, then reaches for tools. Before it, say, launches a helper agent or queries a database, it first tries to work out on its own what questions to ask and how to approach the problem, using what it already has.

That's often exactly right — sometimes you do want the model to think the matter through first. But sometimes you want the opposite: for it to first pull in extra context and only then start reasoning.

So when you're moving workflows from 4.7 to 4.8:

Don't flip the model blind, assuming everything will behave the same way.
Watch it for a while and get a feel for how it behaves on your tasks.

What you should see: a model that pauses and reasons before it runs anything. If you need it to pull in context first, say so explicitly in the instruction.

Step 5: Let the model choose the length of its answer

Opus 4.8 sizes the length and detail of its answers to the complexity of the task on its own, instead of holding to one fixed level of verbosity.

In practice:

A simple fact check → a shorter answer.
An open-ended analysis that needs more reasoning → a longer answer.

What you should see: answers that scale with how hard the question is, with no manual length setting.

How to check it's working

Don't start from benchmarks — start from your own pain points with 4.7. A new model's benchmarks always look great, that's the nature of a launch announcement, but someone else's use case isn't yours.

Work through the list:

Name your pain points with 4.7. Where you keep repeating the same instruction to the model, how often you have to correct it, how fast you're hitting the session limit.
Check the effort level. Type effort and confirm the slider sits where the task needs it, not on the default because you forgot to change it.
Measure concrete things: whether working with it feels better, whether you correct it less, what token use looks like.
Check it against the claim. According to the documentation, the new model is more token-efficient — but that's still something to confirm in your own practice.

One thing Anthropic addresses directly is the model's honesty. A familiar problem with 4.7: the model would say "done, I sent all 50 files" when it had sent 15, or promise four hours of work and finish it in twenty minutes. Opus 4.8 is meant to do this less — if you see that in practice, the change is working.

A better model doesn't automatically mean a better model for the specific problem in front of you. When you choose a model, a context strategy, and an effort level, aim them straight at the constraints you actually have right now. Those, not a benchmark table, will tell you whether the switch was worth it.