Stop Chatting with Claude Code. Start Directing It.

You're directing an agent, not chatting with one

You've built an app, deployed it, and given it a backend. Now level up how you use the tool. Most people use Claude Code like a smarter autocomplete: type a request, watch it edit, approve, repeat. The people getting outsized results have stopped chatting and started directing — treating Claude Code as a controllable agent with gears, shifting deliberately between thinking, executing, and parallelizing.

The gears: permission modes

Claude Code runs in permission modes you cycle with Shift+Tab — the single most important keystroke. The power loop is moving through three gears in order, dropping in two keywords (ultrathink, ultracode) where they earn their keep.

Start in Plan mode, always

Shift+Tab until you see plan mode. Claude can read your whole codebase but is physically incapable of editing. That's the most valuable mode in the tool:

• You catch wrong assumptions before they cost you — a paragraph to fix, not fifteen wrong edits to unwind.
• The plan becomes a contract — approve it and execution follows it.
• It's the cheapest place to iterate — you're refining words, not diffs.

Don't accept the first plan. Argue with it:

> What are two other ways to structure this? Trade-offs?
> What's the riskiest step, and what happens if it's wrong?
> Which existing code does this duplicate — can we reuse instead?

Spend reasoning where it matters: ultrathink

Trigger words escalate the reasoning budget: think → think hard → think harder → ultrathink. Spend it on the genuinely hard calls — concurrency, schema migrations, "one service or two" — not on renaming a variable. Highest leverage during planning:

> ultrathink about the race between the retry and the idempotency
  check in our order handler, then plan a fix without a distributed lock.

Execute on autopilot: auto mode

Plan approved, reasoning done — Shift+Tab into auto-accept and let Claude run. Approving twenty consecutive edits adds only latency and rubber-stamping.

Trust calibration is the real skill: tight plan + small blast radius = auto mode. Vague plan, or auth/billing/migrations = stay in normal and review every step.

Get work off your screen: background & remote

• Background tasks — kick off something slow (test suite, build, backfill) and keep working; Claude pings you when done.
• Remote sessions — launch agents in the cloud (including Claude Code on the web) that run independently of your laptop.

Go wide: ultracode & multi-agent workflows

For tasks too big for one context window — a repo-wide migration, an exhaustive audit — say ultracode to fan out a fleet of subagents that work in parallel, then synthesize one answer.

• Fan-out / map — one agent per file or service, all at once.
• Pipeline — each item flows through find → verify → fix independently.
• Adversarial verify — skeptic agents try to refute each finding.
• Loop-until-dry — keep hunting until N rounds turn up nothing new.

Run an ensemble: pair with Codex

Claude Code can hand work to Codex through a shared runtime for a second implementation, diagnosis, or cross-model review — set up with codex:setup, invoke with codex:rescue or just "use Codex." Claude orchestrates and reviews; Codex is a second pair of hands whose work gets checked.

Close the loop: never report "done" on trust

"Tests green" and "the thing works" are different claims. Run it, verify it, review it — then ship.

Force multipliers & the anatomy of a CLAUDE.md

The CLAUDE.md you saw in every part of this series is the highest-ROI file in a repo — read every session. Run /init to scaffold one; here's the shape:

# CLAUDE.md

## What this is
One line: what the project is, its stack, who it's for.

## Commands
- Install / Dev / Build / Test / Lint — the exact commands, copy-pasteable.

## Conventions
- "We use X, not Y." Where things live. How data flows.

## Do not touch
- generated/**, secrets, protected paths.

## Verifying a change
- How to prove it works before saying done.

Beyond CLAUDE.md: custom slash commands & skills (encode a workflow once), subagents (offload a search to its own context), MCP (connect GitHub, Jira, your cloud), and hooks (auto-format, lint, block protected paths — run deterministically).

Habits & common mistakes

• Give it a way to check its own work — "run the tests after each change and fix failures."
• Interrupt early with Esc; /clear between unrelated tasks.
• Be specific and point at files with @; paste errors and screenshots.
• Commit often, keep diffs small — a 600-line agent diff is a code smell.
• Don't skip plan mode on "small" tasks, rubber-stamp plans, ultrathink everything, auto-mode risky code, or ship on "tests pass" alone.