There's a mode in Claude Code that breaks your task into parallel worker agents, runs them simultaneously, and compiles the results.
It's activated by an environment variable. It's not in the documentation. It's been there for a while.
Here's what it does, why it matters, and how to use it.
What coordinator mode actually is
When you set CLAUDE_CODE_COORDINATOR_MODE=1 and start a session, Claude's architecture changes. Instead of being a single assistant executing one task at a time, it becomes a coordinator: a manager that reads your request, decomposes it into independent subtasks, assigns each to a worker agent, and runs them all simultaneously.
The worker agents execute in parallel. When they finish, the coordinator compiles the results.
This isn't a new prompting technique. It's a different execution model baked into the binary.
A concrete example: "Write 8 blog posts on these topics." In standard mode, Claude writes them one by one. In coordinator mode, it spins up 8 workers — each handles one post — and all 8 run at the same time. The task that takes 45 minutes takes 6.
How to use it
The simplest way:
CLAUDE_CODE_COORDINATOR_MODE=1 claude
Then prompt naturally. You don't have to tell Claude to decompose the task. It recognizes the request structure and handles the distribution automatically.
For a persistent shortcut, add this to your PowerShell profile or .zshrc:
# PowerShell
function claude-multi {
$env:CLAUDE_CODE_COORDINATOR_MODE = "1"
claude --effort max @args
Remove-Item Env:CLAUDE_CODE_COORDINATOR_MODE -ErrorAction SilentlyContinue
}
# bash / zsh
alias claude-multi='CLAUDE_CODE_COORDINATOR_MODE=1 claude --effort max'
What it's actually useful for
Coordinator mode is optimized for tasks with independent, parallel subtasks. Where sequential execution is the bottleneck, this removes it.
The patterns that work:
Content at scale. Ten blog posts, five landing pages, eight email sequences for different audiences. Pass the topics as a list. Coordinator mode assigns one worker per post. They write simultaneously.
Multi-site audits. "Audit these six websites for SEO gaps." Six workers in parallel. What used to be a half-day of context-switching is a single command.
Parallel research. "Research these twelve companies as potential clients." Each worker handles one company — web search, LinkedIn, recent news, fit assessment. Results compile into a single report.
Simultaneous builds. Building similar components, pages, or features for different use cases. Coordinator mode handles the structural repetition so you can focus on the variation.
The limits: it's most effective on 3-15 parallel tasks. Beyond that, context management becomes the constraint. For very large batches, split into multiple coordinator runs.
The --effort flag
While I'm on undocumented features: there's an --effort flag.
claude --effort max
claude --effort low
Levels: low, medium, high, max.
--effort max means Claude allocates more reasoning capacity per response. Deeper analysis. More careful outputs. Use it for anything that will be seen externally — client deliverables, published content, architectural decisions.
--effort low is fast and cheap. Good for quick lookups and file reads where you don't need depth.
The difference is meaningful for complex tasks. For anything important, --effort max is the right default.
Other confirmed hidden features
From digging through the source this week, a few more worth knowing:
--worktree / -w — Creates an isolated git worktree for the session. Your main branch stays clean. Experimental work happens in its own branch automatically. Useful for any session where you're not sure where you're going yet.
AUTOCOMPACT_PCT_OVERRIDE — Controls when Claude compacts context. The default is around 70% — Claude starts trimming when the context window is 70% full. Set this to 88 and you keep more context before it compacts. Less information loss mid-task.
MAX_THINKING_TOKENS — Increases the thinking budget per response. More internal reasoning before output. Set it to 16000 and you notice the difference on hard problems.
Hidden slash commands. There are 26 of them. The ones I use:
/dream— Memory consolidation. Claude reorganizes and compresses session memory. Run at the end of long sessions so the next session starts sharp./summary— Renders a structured summary of the current session or project. Good for handoff docs mid-session./env— Inspect active environment variables. Useful for debugging setup./reset-limits— Reset rate limit state.
Why this is the architecture, not the features
The pattern matters more than any individual flag.
Claude Code ships with far more capability than the documentation describes. The coordinator mode, the effort levels, the worktree isolation — these aren't easter eggs. They're architectural choices about how the tool should handle scale and complexity.
The documentation describes Claude as an assistant. The binary describes something closer to a runtime.
That framing changes what you build. If the tool is an assistant, you optimize for prompts. If it's a runtime, you optimize for systems: configuration, automation scripts, agent definitions, session rituals. The outputs compound differently.
I've been building in that second frame. These are the flags that made it tractable.
The question I keep returning to: how much of what we think are Claude's limits are actually just the defaults we never changed?
The complete configuration kit — settings, templates, scripts, and the full hidden features reference — is available at vibetokens.io/operator.
