When developers get their hands on a new "thinking power" dial for a neural network, the first instinct is to crank it straight to eleven. It feels logical: why settle for a shallow answer when you can push the model to think as hard as possible? In Anthropic's terminal agent Claude Code, however, that maximalism brings a rude awakening. You send off a simple task, walk away to grab a coffee, and come back forty minutes later to find the terminal still testing hypotheses, burning tokens, and building elaborate abstractions around a twenty-line script.
The effort parameter is designed to put an end to that dilemma. Anthropic's team, led by Thariq Shihipar and Lydia Hallie, formalized the agent's compute budget into five distinct levels: from the instant sprint of low to the autonomous marathon of max. Let's look at how this scale works, where the highest setting genuinely saves a project, and when it just drains your API balance.
Five Tiers of Thinking: From Sprint to Marathon
Under the hood, the effort parameter governs the reasoning budget. It dictates how many internal steps, filesystem reads, hypothesis checks, and linter runs the agent can take before deciding it is ready to hand an answer back to you.
Anthropic's engineers broke this down into five discrete tiers:
low— quick-response mode. The agent grabs the first viable hypothesis, makes minimal tool calls, and returns control right away. Great for markup, boilerplate generation, and function stubs.medium— the balanced everyday mode. The model runs basic self-checks without disappearing into deep philosophical debates over your codebase.high— thorough auditing with edge-case modeling. The agent actively tests alternative implementation paths, tracks down side effects, and runs the test suite.xhigh(extra high) — a specialized profile for long-running sessions (30+ minutes) requiring hundreds of steps and millions of tokens on flagship reasoning models.max— full-autonomy ("one-shot") mode. The model aims to solve a major architectural problem without pausing to ask you follow-up questions.
The Anatomy of Overload: 1.5 Minutes vs. 67 Minutes
Benchmarks on Claude Opus show vividly why you shouldn't leave max switched on all the time. In a test building a web app prototype from a short prompt, low finished in 1.5 minutes. The model assembled a clean interface, wired up charts, and delivered a working result. The exact same prompt on max took 67 minutes—44.6 times longer! The agent built out a complex simulation, burning through a massive pile of tokens where only a rough concept was needed.
Still, you can't write off the deeper modes. On TerminalBench 3.0, stepping up from low to max raised the number of solved tasks from 140 to 214 out of 370 (a +52.8% efficiency jump). On unconventional data-processing problems, low scored 0 out of 5, grabbing the first method it saw. At high, the score hit 4 out of 5: the agent tested two different algorithms, spotted an anomaly in the input data, and rewrote the parser.
If you are building workflows around a terminal agent, it is worth revisiting our breakdown on optimizing Claude Fable 5 and cutting token spend, as well as the practical token-saving stack for Claude Code. The new effort parameter brings those same principles straight to the command line.
In Practice: CLI Flags, Session Commands, and Caching
You can control the effort level in three ways. For one-off terminal runs, pass the --effort flag:
# Quick scaffold without overthinking
claude --effort low "Create a TypeScript project structure for parsing OpenAPI specs"
# Deep hunt for an intermittent concurrency bug
claude --effort high "Analyze the race condition in worker_pool.ts and write stress tests"
# Set a comfortable default in your shell profile
export CLAUDE_CODE_EFFORT_LEVEL=medium
Inside an active Claude Code session, there is no need to restart—just run /effort or open the global /config menu:
# Check current model configuration and context usage
/config
# Switch instantly to budget mode for minor edits
/effort low
# Step up to strict verification before committing
/effort high
Don't lock a session to a single level. Start breaking down the task on low or medium. Once the skeleton is in place, switch to high to write unit tests and verify edge cases. This approach saves up to 70% of your tokens without sacrificing final code quality.
Knowing When to Hit the Brakes
Keep the architectural trade-offs in mind. Dynamically switching reasoning levels via /effort mid-conversation can invalidate Prompt Caching, temporarily increasing time-to-first-token latency. On top of that, max mode tends to over-engineer trivial tasks: seeing a huge step budget, the model starts unnecessarily refactoring neighboring modules and inventing extra abstractions.
Save max and xhigh for genuinely large-scale problems where the cost of a mistake is high and you are ready to let the agent run unattended. For day-to-day development, sticking to medium with targeted bursts of high remains the fastest, cheapest, and most reliable play.


