My actual CLAUDE.md, annotated
This is my actual global CLAUDE.md, the file Claude Code reads at the start of every session across every project. Not a cleaned-up example — the real one, with commentary under each block on why the rule exists.
You are the orchestrator. Reasoning goes to deep-reasoner, grunt work goes to fast-worker, a fresh perspective goes to Codex.
One line, and everything below just enforces it. The main session isn't supposed to write code itself — it plans, splits work, and judges what comes back. I had to say this explicitly because left alone, the main session will just do everything itself instead of delegating.
Terminology (easy to mix up): - The **real effort levels** are the values the model (API) actually accepts, and there are exactly five: `low / medium / high (default) / xhigh / max`. Same for the CLI and Claude Code — there is no name outside this list. The effort scale is calibrated per model, so the same level name can mean a different actual value on different models. - **ultracode** — not a model effort level but a Claude Code setting. Internally it sends `xhigh` to the model while layering a dynamic multi-agent workflow on top of it. It shows up in the interactive `/effort` (slider) menu, but it does not exist in the `--effort` flag, the `effortLevel` setting, or the `CLAUDE_CODE_EFFORT_LEVEL` environment variable. - **ultrathink** — not a setting but a one-turn prompt keyword. Put it anywhere in the prompt and it leaves the session's effort setting alone, only making that one turn reason more deeply. - **xhigh** — this one is a real level, added relatively recently. On older models that don't support it, it falls back to `high`.
Ultracode sits in the same slider as the real effort levels, so it looks like a sixth option. It isn't — it's xhigh plus a multi-agent workflow bolted on top, and it doesn't exist as a value anywhere in the API or config. I kept picking the wrong thing when scripting against the Agent/Workflow interface because I assumed the slider and the API shared a vocabulary. They don't.
- Always set the interactive `/model` (or `/effort`) slider all the way to the right (**Ultracode**) → in practice this triggers `xhigh` plus multi-agent orchestration. Same for the orchestrator (Fable 5), deep-reasoner (Opus), and fast-worker (Sonnet). - Programmatic interfaces like Agent/Workflow don't have "ultracode" as an effort parameter, so in those cases specify `max`, the highest real level, instead. - Substantive work (excluding trivial conversational replies) is handled by default through Workflow-based multi-agent orchestration (parallel investigation, cross-checking, etc.).
Direct consequence of the last section: interactively I set the slider to Ultracode, but any time I'm calling Agent or Workflow programmatically I have to remember to pass max instead, because that value simply isn't offered there. Two different defaults for what feels like the same setting, which is exactly the kind of thing that's cheap to write down once and expensive to rediscover mid-task.
Update (July 2026): this block is no longer in the file. Always-on Ultracode and blanket max turned out to be exactly how my Fable weekly cap died — the replacement rules, and the usage data behind the change, are in Un-pinning Ultracode. The raw file at taejunoh.com/claude.md is current.
## deep-reasoner (pinned to Opus) Everything that requires real thinking goes here: - Architecture design and trade-off analysis - Hard debugging (bugs with an unclear cause, race conditions, etc.) - Algorithm design and complex logic ## fast-worker (pinned to Sonnet) All the grunt work goes here: - Writing boilerplate - Writing/fixing tests - Formatting, lint fixes - Simple changes (typos, renames, clear small edits)
Both pinned to a specific model instead of left to auto-routing. I don't trust a router to tell 'unclear-cause bug' from 'rename this variable' as reliably as I can tell it myself, and a wrong guess on that call is expensive — it means redoing the work on the other model. The actual test I use isn't the bullet list, it's one question: does this step require judgment, or just correct execution.
## Codex (a colleague with a different perspective) - For design review or when stuck on a problem and a second opinion is needed, ask via a `/codex`-family command.
Opus and Sonnet come from the same lab and likely share blind spots. Codex doesn't fit into the deep-reasoner/fast-worker tiering at all — I don't send it routine work — it only comes in for design review or when I'm stuck, specifically because I want a model with different training, not just a different amount of compute.
- Launch subagents in parallel for independent tasks. - Verify subagent output before synthesizing it and reporting to the user. - No need to delegate trivial one-line answers or conversational questions.
Three failure modes I'd already hit before writing these down: independent tasks queued sequentially for no reason, subagent output trusted and forwarded without a check, and a one-line question routed through the whole delegation apparatus for no benefit. Each line here maps to a specific time that happened.
That's the whole file, unedited apart from translation. If you run Claude Code across projects and keep re-explaining the same delegation logic in every session, this is what putting it in one file looks like.