Choosing an effort level in Claude Code

Why this decision is different inside an agentic tool

Choosing an effort level for a single API call is a straightforward cost-versus-quality trade for one request. Inside Claude Code, the same setting applies across a whole agentic session — reading files, planning an approach, making edits, checking the result — and the effect of getting it wrong compounds across every one of those steps rather than showing up once. An effort level that's too low for the task doesn't just produce one weaker answer; it can produce a plan built on under-considered reasoning that then gets executed across a dozen file edits before anyone notices the plan itself was the problem.

The default exists for a reason

Claude Code's default leans toward the higher end of the available range for exactly this reason — agentic coding work tends to be the kind of intelligence-sensitive task that benefits most from real reasoning depth, and the cost of under-thinking a multi-step task that then has to be partly undone is usually higher than the cost difference between effort levels would suggest on its own. Dropping below the default is a deliberate trade worth making consciously, not a setting to lower reflexively because a task looks simple at a glance.

Where dropping effort level genuinely makes sense

The cases where a lower effort level is the right call inside Claude Code tend to share a property: the task is genuinely narrow and low-ambiguity, where more reasoning wouldn't change the outcome because there isn't much to reason about. A scoped, repetitive edit across many similar files, a lookup that has one correct answer, a subagent handed a narrow investigative task — these can run at a lower effort level without the risk that applies to open-ended planning or judgment calls about approach.

Where raising it past the default pays for itself

The inverse case — pushing effort higher than the default — earns its cost on genuinely hard problems: a refactor with real architectural trade-offs, a bug whose cause isn't obvious from the visible symptoms, anything where the actual difficulty is in figuring out the right approach rather than in typing out a known one. The highest levels exist specifically for this category of work, where diminishing returns are a real risk on easier tasks but the marginal reasoning quality matters most on hard ones.

Effort level and plan mode work together

A task that's ambiguous enough to warrant a higher effort level is often also a task worth running through plan mode — the two decisions aren't independent, and a good rule of thumb is that whatever makes you consider raising effort level (real ambiguity, real stakes in getting the approach right) is usually also a signal that reviewing the plan before it executes is worth the extra step. See Claude Code plan mode, explained for that half of the pairing.

Setting a project default versus deciding per task

A project that's mostly one kind of work — routine maintenance, say, versus genuinely hard architectural changes — can benefit from a project-level default effort setting rather than deciding fresh every session, the same way permission defaults get set once at the project level rather than reconsidered per task. See the Claude Code config file, field by field for where that default lives, and reserve manual overrides for the sessions that genuinely deviate from what the project's typical task looks like.

The cost side of the decision

Effort level is one of the largest single levers on what an agentic session actually costs, more so than model choice in isolation for many workloads, because it compounds across every reasoning step in a multi-step task rather than applying once. See the effort & thinking cost estimator for how that cost curve looks in isolation before deciding where your own default should sit.