Claude Code Effort Levels Explained: Low, Medium, High, Max, and Ultra Code
Claude Code's /effort command controls how hard the model reasons before acting. Learn when to use each level and what Ultra Code dynamic workflows actually do.
What the /effort Command Actually Does in Claude Code
If you’ve been using Claude Code without touching the /effort command, you’ve been leaving performance on the table — or spending more tokens than necessary on tasks that don’t need it.
Claude Code’s /effort setting controls how deeply the model reasons before it acts. Specifically, it manages the thinking token budget: the internal scratchpad Claude uses to plan, evaluate, and self-correct before writing a single line of code. The higher the effort level, the more thinking tokens the model allocates, and the more deliberate its output tends to be.
This matters because not every coding task deserves maximum reasoning. Writing a one-line utility function doesn’t need the same cognitive overhead as refactoring a 3,000-line service class. Matching effort to task complexity keeps your workflow fast where speed matters and thorough where correctness matters.
This guide covers all five effort levels — Low, Medium, High, Max, and Ultra Code — explains what’s actually happening under the hood, and walks through when to reach for each one.
How Claude Code’s Thinking Budget Works
Before getting into the individual levels, it helps to understand what a “thinking budget” means in practice.
Claude’s extended thinking feature lets the model reason through a problem privately before producing a response. This reasoning isn’t visible in the final output — it’s more like scratch work. The model uses it to consider edge cases, check its assumptions, and plan an approach before committing.
The /effort command controls how many tokens that scratch work can consume. A low budget means Claude reasons briefly and moves fast. A high budget means Claude takes its time — exploring more possibilities, catching more errors, producing more deliberate output.
The tradeoff is straightforward: more thinking tokens = higher quality on complex tasks, but slower responses and higher API costs.
You set effort level at the start of a session (or mid-session if your needs change) by typing /effort [level] in the Claude Code interface. The setting persists for that session unless you change it.
The Five Effort Levels, Explained
Low Effort
Low effort is Claude Code operating with a minimal thinking budget. The model responds quickly, makes fast decisions, and doesn’t spend time second-guessing itself.
What it’s actually doing: A small number of thinking tokens — roughly in the range of 1,000 or fewer — are allocated before Claude acts. It’s enough to understand the immediate request but not enough to reason through complex dependencies or catch subtle bugs.
When to use it:
- Writing boilerplate code you’ll review anyway
- Generating quick scaffolding or starter files
- Asking simple factual questions about a codebase
- Rapid prototyping where iteration speed matters more than precision
When to avoid it:
- Anything involving business logic, security-sensitive code, or multi-file refactors
- Tasks where a subtle bug would be expensive to find later
Low effort is best thought of as a first-pass tool. You get output fast, review it yourself, and iterate.
Medium Effort
Medium effort is the default for most users and most tasks. It represents a balanced thinking budget — enough reasoning capacity to handle moderately complex problems without the cost or latency of higher levels.
What it’s actually doing: Claude allocates a moderate thinking budget, roughly in the range of 4,000–6,000 tokens. It can reason through basic logic, consider a handful of edge cases, and produce code that’s more self-consistent than low-effort output.
When to use it:
- Writing functions with non-trivial logic
- Explaining how an existing piece of code works
- Generating unit tests for straightforward components
- Code review on moderately complex files
- General-purpose coding assistance during a normal session
For most day-to-day development work, medium effort hits the right balance. You get quality output without paying the latency penalty of high or max.
High Effort
High effort is where Claude Code starts functioning more like a careful engineer than a fast typist. The thinking budget expands substantially, and Claude uses that space to reason more thoroughly before acting.
What it’s actually doing: The thinking token budget scales up to roughly 10,000 tokens or more. Claude has enough headroom to reason through multi-step logic, consider competing implementation approaches, and self-check its reasoning before producing output.
When to use it:
- Refactoring complex functions or modules
- Debugging non-obvious issues (especially cross-file problems)
- Writing code that will be difficult to change later
- Implementing algorithms with correctness requirements
- Generating code in unfamiliar languages or frameworks where errors are less obvious
High effort noticeably increases response time. For a complex task, expect to wait longer — but the output tends to require less correction.
Max Effort
Max effort gives Claude Code the largest available thinking budget. The model reasons as thoroughly as the system allows before producing any output.
What it’s actually doing: Claude uses the maximum thinking token allocation, which can run into the tens of thousands of tokens depending on context. It’s using that budget to explore the problem space deeply — considering multiple approaches, checking for inconsistencies, reasoning about failure modes.
When to use it:
- Architecting a new system or making high-stakes design decisions
- Debugging the hardest class of bugs: race conditions, heisenbugs, subtle type errors
- Producing security-critical code that needs to be correct the first time
- Long-horizon planning tasks: “What changes do I need to make across this repo to support feature X?”
- Code that integrates multiple systems and has complex failure modes
Max effort is expensive in both time and tokens. Use it when the cost of a mistake is high and the value of getting it right the first time justifies the overhead.
Ultra Code
Ultra Code is a different kind of setting than the others. Where Low through Max control a static thinking budget, Ultra Code refers to a dynamic workflow mode — one where Claude autonomously adjusts how much reasoning it applies depending on what it encounters during a task.
What it’s actually doing: Instead of a fixed thinking budget, Ultra Code lets Claude escalate its reasoning mid-task when it detects complexity or uncertainty. For straightforward steps, it reasons efficiently. When it hits a genuinely difficult problem — an unexpected dependency, an ambiguous requirement, a tricky edge case — it pulls in more thinking capacity automatically.
This makes Ultra Code particularly valuable for long-running agentic sessions where the complexity isn’t uniform. A task might start simple and get complicated. With a fixed effort level, you’d either overspend on the easy parts or undershoot on the hard ones. Ultra Code adapts.
When to use it:
- Multi-step agentic tasks that span many files or systems
- Autonomous coding sessions where you want Claude to handle complexity without manual intervention
- Projects where you can’t predict upfront which parts will be hard
- Long sessions where you want to set effort once and trust the model to manage it
The key difference: With Max, you’re telling Claude “reason hard on everything.” With Ultra Code, you’re telling Claude “reason as hard as you need to, wherever you need to.”
Choosing the Right Effort Level: A Practical Guide
The right level depends on three variables: task complexity, tolerance for errors, and how much latency you can accept.
| Task Type | Recommended Level |
|---|---|
| Quick syntax questions | Low |
| Generating boilerplate | Low–Medium |
| Writing business logic | Medium–High |
| Unit tests for complex code | Medium–High |
| Cross-file refactoring | High |
| Debugging subtle bugs | High–Max |
| Security-critical code | Max |
| Architecting new systems | Max |
| Long agentic multi-step sessions | Ultra Code |
| Complex projects with variable difficulty | Ultra Code |
A few rules of thumb:
- If you’ll review and edit the output anyway, lower effort is fine. You’re the safety net.
- If the code will ship with minimal review, higher effort is worth the cost.
- If you’re running Claude autonomously, Ultra Code handles variable complexity better than any fixed level.
How MindStudio Fits Into Claude Code Workflows
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
Claude Code’s /effort levels are most powerful when Claude is acting as an autonomous agent — not just answering questions, but actually executing multi-step tasks. That’s where the scope of what Claude can do starts to matter as much as how hard it reasons.
By default, Claude Code’s reach is limited to your local codebase. It can read files, write code, and run commands in your terminal. But many real-world tasks require more: sending a notification, searching the web, triggering a pipeline, generating an image, calling an external API.
The MindStudio Agent Skills Plugin bridges that gap. It’s an npm SDK (@mindstudio-ai/agent) that gives any AI agent — including Claude Code — access to 120+ typed capabilities as simple method calls. Instead of writing integration code for every external service, you call methods like:
agent.sendEmail({ to: "team@example.com", subject: "Deploy complete" })
agent.searchGoogle({ query: "latest React 19 breaking changes" })
agent.runWorkflow({ workflowId: "notify-slack-on-failure" })The plugin handles auth, rate limiting, retries, and error handling — the infrastructure layer that usually consumes developer time. Claude Code focuses on reasoning and logic; MindStudio handles execution against external systems.
This pairs especially well with Ultra Code sessions. When Claude is dynamically managing its own reasoning effort across a long autonomous task, it benefits from having reliable, low-friction tools to act with. The Agent Skills Plugin gives Claude Code that expanded capability surface without adding implementation complexity.
You can start using MindStudio free at mindstudio.ai.
Common Mistakes When Using Effort Levels
Using Max for everything
Max effort is genuinely better for hard problems. But it adds latency and token cost on every interaction — including the simple ones. If you’re working interactively, running on Max for quick questions means waiting longer and spending more for no real benefit.
Forgetting to adjust mid-session
If a task shifts from simple to complex, your effort level should too. You can change it at any point with /effort [level]. Don’t let inertia keep you on Low effort when the problem has gotten complicated.
Treating effort level as a quality guarantee
Higher effort makes Claude reason more carefully. It doesn’t make Claude correct. On highly complex tasks, even Max effort can produce code that needs review. Effort levels shift the probability of getting it right — they’re not a substitute for understanding the output.
Ignoring Ultra Code for agentic sessions
If you’re running Claude autonomously on tasks you don’t know the full shape of, Ultra Code is almost always the right choice over a fixed level. Fixed levels force a binary choice — too conservative or too expensive. Dynamic adjustment handles real-world complexity better.
Frequently Asked Questions
What is the /effort command in Claude Code?
The /effort command sets the thinking token budget Claude uses before producing output. A higher budget means Claude reasons more thoroughly — considering more edge cases, checking its logic, evaluating alternatives — before writing code. A lower budget means faster, lighter responses. You type /effort low, /effort medium, /effort high, /effort max, or /effort ultra (for Ultra Code mode) to change the setting.
How does effort level affect token usage and cost?
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
Higher effort levels consume more thinking tokens per interaction, which increases API cost. The relationship isn’t linear — going from Low to Medium is a moderate jump, while going from High to Max is a larger one. For high-volume or interactive use, keeping effort at Medium for routine tasks and escalating selectively is a practical cost management strategy.
When should I use Max effort vs. Ultra Code?
Use Max when you have a specific complex task and want Claude to reason as hard as possible throughout. Use Ultra Code when you’re running a long autonomous session with variable complexity — tasks where some parts are simple and some are hard, and you want Claude to allocate reasoning effort intelligently rather than applying maximum effort uniformly. Ultra Code is the better fit for agentic workflows; Max is better for targeted high-stakes single tasks.
Does effort level affect creativity or output style?
Primarily, effort level affects reasoning depth and correctness. At higher levels, Claude is more likely to catch its own errors, consider edge cases, and produce well-structured output. The stylistic qualities of the output don’t change dramatically — what changes is how thoroughly Claude thinks through the problem before committing to an approach.
Can I change the effort level during a session?
Yes. You can change it at any point by typing /effort [level]. The change takes effect immediately for subsequent messages. This means you can work at Medium for general tasks and switch to Max when you hit a problem that needs more care, then switch back.
Is Ultra Code available in all versions of Claude Code?
Ultra Code’s availability depends on the version of Claude Code you’re running and the model context you’re using. Dynamic effort adjustment typically requires model versions that support extended thinking with variable budgets. Check the Anthropic documentation for the current state of extended thinking support in Claude Code.
Key Takeaways
- Low effort is fast and cheap — right for simple tasks you’ll review yourself.
- Medium effort is the default and covers most day-to-day coding work well.
- High effort is worth the cost for complex logic, debugging, and code that’s hard to change later.
- Max effort is reserved for the hardest problems: architecture decisions, security-critical code, and subtle multi-file bugs.
- Ultra Code is different from the others — it dynamically adjusts reasoning depth based on task complexity, making it the best choice for long autonomous sessions.
- Matching effort to task type is a skill. Overusing Max wastes money and time; underusing it on hard problems produces errors that cost more to fix later.
If you’re running Claude Code as part of a larger agentic workflow — especially one that reaches outside your local codebase — pairing it with a tool like the MindStudio Agent Skills Plugin gives it the broader execution capabilities that make high-effort autonomous sessions actually useful. Try it free at mindstudio.ai.
