How to Use Claude Code Effort Levels: Low, Medium, High, Max, and Ultra Code

Why Claude’s Effort Level Is One of the Most Impactful Settings Most People Ignore

When you’re running Claude in an agentic coding context, the single biggest lever you have over quality, cost, and speed isn’t your prompt. It’s how much thinking you ask Claude to do before it acts.

Claude’s effort levels — Low, Medium, High, Max, and Ultra Code — control how many tokens Claude spends on internal reasoning before it produces output. Get this setting wrong and you’re either burning money on overthought simple tasks or getting shallow answers to genuinely hard problems. Match the effort to the task, and Claude Code performs measurably better at a fraction of the unnecessary cost.

This guide breaks down all five Claude effort levels, explains the tradeoffs, and gives you a practical framework for choosing the right one every time.

---

What Claude Effort Levels Actually Control

Effort levels in Claude Code are directly tied to Claude’s extended thinking capability. When Claude thinks before responding, it allocates a budget of tokens to internal reasoning — working through the problem before writing a single line of output.

More thinking tokens = more deliberate reasoning = better results on complex, ambiguous, or multi-step problems. Fewer thinking tokens = faster, cheaper responses that are perfectly adequate for well-defined, simple tasks.

The five effort levels map to different thinking token budgets:

Effort Level	Thinking Budget	Best For
Low	Minimal (~1,024 tokens)	Simple lookups, formatting, boilerplate
Medium	Moderate (~4,000 tokens)	Routine coding tasks, standard refactors
High	Substantial (~8,000 tokens)	Complex logic, architecture decisions
Max	Maximum standard budget	Hard debugging, multi-file reasoning
Ultra Code	Extended maximum	Extremely complex or high-stakes code

The practical implication: if you run every task at Max or Ultra Code, you spend significantly more per interaction. If you run everything at Low, you’ll see shallow, error-prone outputs on tasks that actually need deliberate reasoning.

---

Breaking Down Each Effort Level

Low Effort

Low is Claude at its most efficient. The internal thinking budget is minimal, meaning Claude answers quickly with little pre-processing.

This isn’t a “worse” mode — it’s a correctly scoped mode for tasks where the answer is already well-constrained. Think of it as Claude in reflex mode.

When to use Low:

• Renaming variables or functions
• Adding docstrings or comments to simple functions
• Generating boilerplate (CRUD endpoints, test stubs, config files)
• Quick syntax lookups or language comparisons
• Reformatting or restructuring code without changing logic

What to watch out for: Low effort produces poor results when the task has hidden complexity. A prompt like “refactor this function” might look simple but hide tricky edge cases that need deliberate reasoning.

Medium Effort

Medium is the practical default for most everyday coding work. Claude gets a meaningful thinking budget — enough to hold context, consider a few approaches, and reason through straightforward problems without going deep.

Most developers should start here and adjust up or down based on results.

When to use Medium:

• Writing a new function with moderate logic
• Implementing a feature that spans one or two files
• Standard code reviews
• Fixing a bug with a clear error message and obvious scope
• Writing unit tests for an existing function

Medium is well-balanced for the majority of coding tasks that aren’t trivially simple but aren’t architecturally complex either.

High Effort

High effort is where Claude starts doing real deliberative reasoning. With a substantially larger thinking budget, it can consider multiple approaches, anticipate downstream consequences, and produce more thoughtful output.

You’ll notice the difference in how Claude handles ambiguity. At Low or Medium, Claude often picks the most obvious interpretation. At High, it’s more likely to flag the tradeoffs or ask a clarifying question before proceeding.

When to use High:

• Implementing complex algorithms or data structures
• Writing code that interacts with several systems at once
• Architecture decisions with meaningful long-term consequences
• Debugging issues where the cause isn’t immediately obvious
• Building something that needs to handle edge cases robustly

High effort adds latency and cost, but for tasks in this category, the output quality difference is significant.

Max Effort

Max represents the ceiling of Claude’s standard extended thinking budget. At this level, Claude can sustain deep, multi-step reasoning across long, complex problems.

This is the right choice when the task is genuinely hard — when a human expert would need significant time to think through it carefully.

When to use Max:

• Cross-file refactors that touch shared state or side effects
• Debugging intermittent or environment-dependent bugs
• Security-critical code that needs to reason about attack vectors
• Complex state management or concurrency issues
• Building something from scratch where the design space is wide open and the stakes are high

Max is noticeably more expensive per run. Use it deliberately, not as a default.

Ultra Code

Ultra Code is Claude’s extended-maximum mode — essentially Max effort with additional headroom for thinking token allocation. This is for the most demanding coding tasks where you genuinely need Claude to exhaust the problem space before responding.

In practice, Ultra Code shines in scenarios where:

• The problem is underspecified and Claude needs to reason through the solution space carefully
• A wrong answer has high downstream cost (production code, security-sensitive logic, financial calculations)
• The task spans a large codebase and Claude needs to hold a lot of context in working memory

Ultra Code isn’t for everyday use. Treat it as a tool for your most complex, highest-stakes coding problems.

---

How Effort Levels Affect Token Spend (The Real Cost Breakdown)

Understanding the cost implication of effort levels matters if you’re running Claude Code at any scale — whether that’s a solo developer with a personal budget or a team running hundreds of agentic tasks per day.

The core principle: thinking tokens add to your total token consumption, and they’re billed like any other tokens. A task that costs 2,000 output tokens at Low might cost 10,000 total tokens at Max when you factor in the thinking budget.

Rough scaling:

• Moving from Low to Medium: expect 2–3x total token usage
• Moving from Medium to High: expect another 1.5–2x increase
• Moving from High to Max: roughly another 1.5x
• Ultra Code can be 5–10x more expensive than Low for the same prompt

For simple tasks like boilerplate generation or quick fixes, running at High or Max is wasteful — you’re paying for thinking that doesn’t improve the output.

For complex, multi-step problems, the math often inverts: it’s cheaper to run one High-effort task successfully than to iterate on three failed Medium-effort attempts.

Practical Cost Optimization Strategy

A useful approach is to run a two-pass process:

1. Classify the task first. Before sending a prompt, ask yourself: Is this constrained or open-ended? Is the correct answer obvious or ambiguous? Are the stakes high or low?
2. Choose the minimum effective effort level. Start one level lower than you think you need, review the output, and escalate if the result is insufficient.

This approach typically reduces token spend by 30–50% on mixed workloads without sacrificing output quality.

---

How to Set Effort Levels in Claude Code

In Claude Code (the CLI agentic coding tool), you can configure the effort level directly in your commands or configuration.

Via the CLI

You can specify effort using the --thinking flag with a budget parameter, or use Claude Code’s built-in effort shortcuts depending on your version:

# Example using explicit thinking budget
claude --thinking high "Refactor the payment module to handle retry logic"

# Or using effort level shorthand
claude --effort max "Debug the race condition in our async queue processor"

Via the /model or /effort Command in Interactive Mode

In interactive Claude Code sessions, you can switch effort levels mid-session:

/effort high

This persists for subsequent prompts in the session until you change it again.

Via Configuration Files

For teams or automated workflows, you can set a default effort level in your Claude Code configuration to avoid setting it manually each time. This is especially useful when you’ve identified that a particular project’s tasks consistently require a specific effort level.

---

Matching Effort to Task Type: A Practical Reference

Here’s a quick-reference breakdown for common coding scenarios:

Always Low:

• Adding type hints to existing code
• Generating repetitive boilerplate (getters, setters, standard CRUD)
• Reformatting code to match a style guide
• Simple regex pattern generation
• Documentation for a single, well-understood function

Usually Medium:

• Writing a new API endpoint
• Implementing a feature based on a clear spec
• Fixing a bug where you’ve identified the root cause
• Writing tests for a function with known behavior
• Simple integrations between two systems

Usually High:

• Writing complex business logic with multiple conditions
• Designing a system component from scratch
• Multi-file refactors with shared state
• Debugging issues with unclear root causes
• Building something with performance or reliability requirements

Usually Max or Ultra Code:

• Security-critical features or audits
• Complex concurrency or async bugs
• Architecture design for systems at scale
• Large-scale code migrations
• Any task where incorrect output has serious consequences

---

Common Mistakes When Using Effort Levels

Defaulting to Max for Everything

The most common mistake. It feels like the “safe” choice — more thinking must mean better output, right? But for simple tasks, the additional thinking doesn’t improve the output. It just adds latency and cost.

If you’re using Max for renaming functions or generating boilerplate, you’re wasting money and time.

Using Low for Anything Requiring Judgment

The opposite mistake. Low effort is genuinely bad for tasks where Claude needs to weigh tradeoffs, handle ambiguity, or reason across multiple files. Using Low on a complex refactor often produces plausible-looking but subtly wrong output.

Not Reassessing When You Get Bad Output

If you get a poor result, the first instinct is often to re-prompt. But sometimes the issue is the effort level, not the prompt. If you’re at Medium and the output is shallow or misses edge cases, try escalating to High before rewriting the prompt.

Using Ultra Code for Time-Sensitive Work

Ultra Code produces better results on hard problems, but it’s slower. If you need a quick answer, even on a moderately complex question, High might get you 90% of the quality at a fraction of the wait time.

---

Where MindStudio Fits Into Claude-Powered Workflows

If you’re using Claude Code effort levels in an automated or agentic context — not just interactively — you’re likely managing a workflow where multiple tasks run sequentially or in parallel. Manually configuring effort per task becomes a bottleneck.

This is where MindStudio is useful. MindStudio is a no-code platform for building AI agents and automated workflows, with access to 200+ models including Claude. You can configure Claude as a step in a larger workflow and set different model parameters — including thinking budget equivalents — per step based on task complexity.

For example: a code review workflow might run a Low-effort pass to identify formatting issues, then escalate to a High-effort Claude step only for the functions flagged as complex. That kind of conditional logic is straightforward to build in MindStudio’s visual editor without writing infrastructure code.

If you’re a developer building custom agents that call Claude programmatically, MindStudio’s Agent Skills Plugin is worth looking at — it lets agents like Claude Code call 120+ typed capabilities as simple method calls, handling auth, retries, and rate limiting automatically.

You can try MindStudio free at mindstudio.ai.

---

FAQ: Claude Effort Levels

What is the difference between Max and Ultra Code in Claude?

Max is Claude’s maximum standard extended thinking budget — a very high token allocation for internal reasoning before responding. Ultra Code pushes beyond this to an extended maximum, offering additional headroom for Claude to reason through extremely complex problems. In practice, Ultra Code is most useful for tasks that are genuinely difficult, underspecified, or high-stakes, where exhaustive reasoning before acting is worth the extra cost and latency.

Does higher effort always produce better output?

No. Higher effort produces better output for tasks that require deliberate reasoning — complex logic, ambiguous requirements, multi-step problem solving. For well-constrained, simple tasks, the additional thinking doesn’t change the output quality. You get the same result at a higher cost.

How do effort levels affect Claude Code’s response speed?

Effort levels directly affect latency. Low and Medium are fast — you get output quickly because Claude’s thinking budget is small. High and Max take noticeably longer. Ultra Code can be significantly slower on complex tasks. If you’re building tools where response speed matters to users, this tradeoff is worth considering carefully.

Can I change the effort level mid-session in Claude Code?

Yes. In interactive Claude Code sessions, you can use the /effort command to switch levels at any point. The new level applies to all subsequent prompts in that session until you change it again.

Is there a way to automate effort level selection?

Not natively within Claude Code, but you can build workflows that route tasks to different configurations based on criteria you define. Tools like MindStudio let you set up conditional logic that selects different Claude parameters — including thinking budget — based on task type, file scope, or other signals. For teams running Claude at scale, this kind of automation can meaningfully reduce costs.

How do I know if I’ve set the effort level too low?

Signs that effort is too low for your task: Claude misses obvious edge cases, provides a single solution without considering alternatives, produces output that looks correct but fails on closer inspection, or gives a shallow answer to a question that warranted deeper analysis. When in doubt, escalate one level and compare.

---

Key Takeaways

• Effort levels control Claude’s thinking token budget — how much internal reasoning happens before output is produced.
• Five levels exist: Low, Medium, High, Max, and Ultra Code — each appropriate for different task complexities.
• Default to Medium for most everyday coding tasks, then adjust based on results.
• Higher effort isn’t always better — for simple tasks, it adds cost and latency without improving output.
• The biggest cost savings come from avoiding Max and Ultra Code on tasks that don’t need them, not from always using Low.
• For automated workflows, configuring effort per task type — rather than using one level for everything — produces the best balance of quality and cost.

Choosing the right effort level is one of the simplest optimizations you can make to your Claude Code workflow. Start with Medium, escalate when results fall short, and build a sense over time for which task types benefit from deeper thinking. That calibration pays off quickly.

If you’re looking to build more sophisticated Claude-powered workflows — where effort levels, model selection, and task routing happen automatically — MindStudio’s visual workflow builder is worth exploring. It takes the infrastructure work off your plate so you can focus on what Claude actually does.