---

1) /effort max — Maximum reasoning budget

What is it?

/effort is a slash command in Claude Code that controls how much compute ("thinking budget") Claude spends on a response. Five levels:

Level	Symbol	Behaviour
low	○	Fast, surface-level. Good for trivial tasks (rename, small edits).
medium	◐	Default. Solid all-rounder.
high	●	Deeper reasoning, more edge cases.
xhigh	◉	Intermediate level (introduced with Opus 4.7).
max	⬭	No token limit. Maximum thinking.

How to enable

In the terminal during a Claude Code session, just type:

/effort max

This applies for the current session. On restart Claude falls back to the default (medium) — unless you set it permanently via the env var:

export CLAUDE_CODE_EFFORT_LEVEL=max

(e.g. in ~/.zshrc or ~/.bashrc)

Effects

What you gain:

• Claude actively hunts for edge cases you didn't mention.
• Finds bugs you haven't seen yourself.
• Considers architecture, performance, and security together.
• Plans multi-step refactors cleanly instead of charging in.
• For complex debugging: 2–3× better hypotheses.

What it costs:

• More wait time (significantly for large tasks — sometimes 30–60 s before the first response).
• More token consumption (relevant on pay-per-token, less on Max plans).
• Overkill for trivia: "rename this variable" doesn't need max.

When to use

✅ Yes to /effort max:

• Architecture decisions, ADRs
• Complex debugging (race conditions, memory leaks)
• Refactors across multiple files
• Code review of critical PRs
• Security reviews

❌ No to /effort max:

• Renaming variables
• Small UI tweaks
• Boilerplate code (forms, CRUD)
• One-liner scripts

2) CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1 — turn off adaptive thinking

What is adaptive thinking?

Adaptive thinking is a feature in Opus 4.6 / Sonnet 4.6+, where the model decides on its own how many reasoning tokens to invest per turn. The idea: think less on easy answers, more on complex ones.

The problem: sometimes the model decides to use zero reasoning tokens — even on tasks where it should think. The result: precise hallucinations:

• Made-up commit SHAs that look plausible.
• Nonexistent apt packages.
• API versions that never existed.
• Function names that don't appear anywhere in the code.

How to enable

Set this in your shell before starting Claude Code:

export CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1

Or add it permanently to ~/.zshrc / ~/.bashrc. Important: env vars are only read when Claude Code starts — so after setting, restart once.

Effects

What happens:

• Claude uses a fixed reasoning budget per turn (driven by MAX_THINKING_TOKENS) instead of deciding for itself.
• Every response gets guaranteed thinking tokens — no more "laziness".
• Massively reduced hallucination rate, especially in code generation with specific library/framework names.

What it costs:

• More overall token consumption (even trivial answers now get thinking).
• Slightly longer response times on simple tasks.

What controls the budget then?

Once adaptive thinking is off, either the MAX_THINKING_TOKENS variable or the effort level (/effort max, etc.) applies. With both together you can configure precisely:

export CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1
export CLAUDE_CODE_EFFORT_LEVEL=max

→ Maximum fixed reasoning effort on every response. That's the "pro mode" config for serious engineering work.