I was fixing the billing flow of one of my wallpaper apps late one evening when I stalled on a small question: should I put "ultrathink" at the front of this prompt or not? It felt like it would make Claude more careful. But I also had a vague impression that my usage drained faster on the days I typed it.
The official changelog had an answer sitting there. Here is what Claude Code v2.1.311 (October 26, 2026) says, limited to what you can verify on your own machine.
What changed in v2.1.311
The changelog has a line to this effect: in the interactive terminal, ultrathink runs its turn at xhigh effort on Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 through Anthropic's API. If you type it while Claude is already working, it raises the rest of that turn.
There is a second change that is easy to miss. The rainbow highlight on ultrathink in the input box now appears only where the keyword can actually raise effort. It does not appear when the word is quoted or is part of a file path.
Three things follow from that:
- The scope is the turn. Your session-wide setting does not change.
- Eligibility depends on the model and the route. Outside the listed models and the API route, you won't see the rainbow.
- The rainbow is your signal that it is in effect.
Raising effort with one word lasts exactly one turn. I build the rest of my habit around that.
How it differs from a standing setting
You can switch effort with /effort, and check the current state with /effort status. You can also pin it with the CLAUDE_CODE_EFFORT_LEVEL environment variable. An earlier fix addressed the prompt's effort indicator showing a guessed level when that variable was auto or unset.
So there are two layers for thinking harder:
| Method | Scope | Best for |
|---|---|---|
| /effort or the environment variable | Every later turn | A stretch of consistently hard work |
| ultrathink in the prompt | Only the turn you typed it in | One spot that deserves deeper thought |
I used to raise the setting on heavy days and leave it there, which meant even trivial questions got the same depth. The results were not great. A one-line "where is this file?" got the long, deliberate treatment, and both my waiting time and my usage grew.
Now I keep the setting at my everyday depth and use ultrathink to lift a single turn when it matters.
When I type it, and when I don't
My rule is simple: how expensive is it to undo a wrong answer?
I type it for:
- The first turn of a design decision that touches several files
- A turn that plans how to isolate a bug whose cause I can't see
- A turn that plans a change that is hard to reverse, such as billing logic or a data migration
I leave it out for:
- Renaming a variable, fixing a comment, tidying formatting
- Continuing an implementation whose approach is already settled
- Quick lookups like "which file defines this?"
When I'm unsure, I ask for a plan first. The planning turn gets ultrathink; the implementation turn does not. What I want deeper thought on is usually what to do, not how to type it.
The same request, written two ways
Take "review the restore-purchase flow" as an example.
Before: ask for the plan and the implementation in one breath.
ultrathink Fix the restore-purchase flow and write tests.Here the one deep turn has to carry both the decision and the implementation. If the decision is off, the deep thinking you paid for goes down with it.
After: lift only the planning turn.
ultrathink List the places the restore-purchase flow could break. Don't implement yet; just propose the order to fix them in.Once I read the proposal and agree with the order, the next turn goes without ultrathink: "implement only the first item." The deep-thinking cost is spent on the one judgment that is hard to undo. For the implementation turn, my everyday depth has almost always been enough.
The side benefit is a checkpoint where I read the result myself. The deeper the thinking, the easier it is to accept a proposal without question, so I prefer having that gate in place.
Reading your usage
You can see usage with /usage. The changelog also mentions that /usage now warns about things like max effort and large tool results, so heavy patterns surface more easily.
The procedure is short:
# 1. Check the baseline effort for the session
/effort status
# 2. Run a few ordinary turns, then look at usage
/usage
# 3. Run one turn with ultrathink at the start of the prompt
# (the rainbow means it is active), then look again
/usageComparing /usage before and after step 3 tells you how heavy that one turn was in your own setup. I won't give you a number to trust; read your own. The order matters because if the baseline is already high, you can wrongly conclude that adding ultrathink changes nothing.
When the rainbow doesn't appear
If you typed ultrathink and see no rainbow, check in this order:
- Is the model one of the four listed? (
/modelshows it.) - Are you going through Anthropic's API? Gateways and some other routes may be out of scope.
- Is the word inside quotes or part of a path?
How Bedrock, Vertex and similar routes behave can't be read from that single changelog line, so I don't claim anything there. I only trust the rainbow.
One step for today
Next time you open Claude Code, run /effort status once. If the baseline is higher than you want, bring it back to your everyday depth. Then, once or twice a day, put ultrathink at the start of a turn where you think, "this one is expensive to get wrong." That small habit is where my own usage settled down, and I'd rather keep it that way.