Don't use ultracode for everything

What it is and why it matters

In Claude Code you can decide how much Claude thinks before it answers you and touches the code. It's called the effort level, and it has five steps: low, medium, high, xhigh and max.

The more it thinks, the slower it is and the more tokens it uses. On a hard job that extra thinking saves you. On a trivial change it's just waiting and usage. The trick is not to pay for thinking you don't need.

On today's models the starting point is medium. I keep it on high for almost everything, and I turn on max only when it's really needed. Claude Code's own documentation warns that max can give back less than it uses and tends to overthink: test it before using it all the time.

Then there's ultracode, which isn't a sixth step. It's a setting that has many agents work in parallel. Useful in a few cases, a waste in all the others. More on it below.

1. How to change the level

1. Type /effort in Claude Code: a slider with the levels opens. Move it with the arrow keys and confirm with Enter.
2. If you already know which one you want, give it directly, like /effort high.
3. You can also do it inside /model: while you pick the model, the left and right arrow keys adjust the level.
4. For a single session you can start from the terminal with claude --effort high.

/effort high

One thing to know. When you pick low, medium, high or xhigh with Enter, or type it after /effort, Claude Code remembers it in later sessions too. Max doesn't: it only lasts for the current session. So if you go up to xhigh, it's on you to remember to come back down.

2. The table: which level for which job

Low: mechanical work

Jobs where there's nothing to decide: Claude just has to carry them out. For example:

Rename this variable everywhere

fix the typos in the copy

Medium: the starting point on today's models

Small, clear jobs in one or two files, where you already know what you want. For example:

add an email field to the form

write the test for this function

High: what I use for almost everything

A button, a page, an ordinary bug. It's the everyday work, where Claude has to understand how the app is built before touching it. For example:

create the pricing page with three plans

login doesn't work on mobile: find out why and fix it

Extra high (xhigh): when high isn't enough

The step before max. A feature that touches several parts of the app, a bug that comes back even after you fixed it. Some older models don't have this level: Claude Code uses the highest one available below it, which is high.

Max: only the truly hard cases

A refactoring that touches everything, a bug nobody has been able to find for days. For example:

move all the user handling into a single module, without breaking anything

Remember that max only lasts for the session where you turn it on.

3. What about ultracode?

Ultracode isn't an extra level. It's a Claude Code setting: when it's on, Claude organizes every substantial job as a workflow, meaning a plan carried out by many subagents working in parallel. A single request can turn into several workflows in a row: one to understand the code, one to make the change, one to verify it.

It runs on top of the level you already have: you can have ultracode on with high or with max. If you turn it on at launch, the level also goes to xhigh.

It uses many more tokens and takes longer. It makes sense when the work really splits into many independent pieces: a full review of a large project, a migration across dozens of files. For an ordinary change it's just waste.

• /effort ultracode turns it on for the current session.
• /effort ultracode off turns it off when you go back to normal work.
• claude --effort ultracode starts a session with ultracode already on.

If you need it for a single task, there's no need to turn it on for the whole session. Put the word ultracode in your prompt and Claude sets up a workflow just for that request. For example:

ultracode: check every page of the app, find the text that isn't translated yet and give me a single list, page by page.

4. The rule in three steps

1. For everyday work, set it to “high”, with /effort high.
2. If nothing comes of it after two attempts, go up (xhigh, then max) and explain what you've already tried.
3. Once the hard job is done, come back down.

For the second step I use a message like this. Going up a level without giving it the context doesn't help much: the extra thinking needs something to work on.

We've already tried twice and it doesn't work. Here's what we did: [what you tried]. Here's what happens now: [the problem]. Before you touch the code, think through why the earlier attempts didn't work and tell me what you want to change.

For the third step, /effort high is all it takes. If you were on max, the next session starts from your saved level anyway. If you were on xhigh, though, that stays saved until you change it.

The highest level isn't the one you need. Almost never.

Common mistakes

• Keeping everything on max “just to be safe”. It's slower, uses more and can overthink: save it for the truly hard cases.
• Turning on ultracode for an ordinary change. Many agents on a small job don't do it better: use it only when the work splits into independent pieces.
• Forgetting ultracode is on. It applies to every request in the session: when the big job is done, type /effort ultracode off.
• Raising the level instead of explaining better. If the request is vague, more thinking won't make it clear: first add the context and what you've already tried.
• Staying on xhigh after the hard job. The level stays saved in later sessions too: once the job is done, go back to high with /effort high.
• Using low for a job that touches several parts of the app. You save at first and then redo everything: if it has to understand how the pieces connect, use at least high.

Checklist

• Everyday work on high (/effort high)
• Low or medium for mechanical and small changes
• Xhigh, then max, only after two failed attempts
• When I go up, I explain what I've already tried
• Ultracode only for jobs that split into many pieces
• Hard job done: back down, ultracode off

Frequently asked questions