The Conductor and the Machine: Orchestrating Claude Code

⚡ TLDR

What it solves: The “babysitting” problem - when an AI agent drifts off-track or ignores project rules because it lacks structure.
Why it matters: Without orchestration, you’re not coding; you’re negotiating with a machine. You spend 80% of your time repeating instructions.
Best for: Developers who have moved past simple chat and are building complex agentic systems with custom tools and multiple agents.
Main differentiator: It codifies the internal logic used by the Anthropic team themselves, focusing on the Command → Agent → Skill pattern.
Usecase example: Building a /deploy command that doesn’t just run a script, but spins up a “QA subagent” to verify the app before a “Skill” handles the actual push to production.

I spent the first week with Claude Code feeling like I was babysitting a genius.

I’d ask it to refactor a component. It would do it, perfectly. Then I’d ask it to run the tests. It would ask me for the command. I’d provide it. Then it would ask if it had permission. I’d say yes. By the time the PR was ready, I felt like I had spent more time typing “yes” and “npm run test” than actually designing the feature.

I thought I was being fast. I was actually just being a well-paid assistant to my own terminal.

Then I found the Claude Code Best Practice repo. And I realized I wasn’t a conductor anymore. I was just part of the audience.

The North Star

Physically, this repository is a collection of Markdown templates, JSON configuration files, and ASCII-diagrammed workflows. It is not a software library you install; it is a Design Language for Agents.

It is the bible of “Agentic Engineering.”

If you’ve ever felt like your AI agent is hitting a wall, it’s probably because you’re treating it like a chatbot. This repo forces you to treat it like a runtime.

The Mental Model: The Conductor and the Score

Think of an orchestra. You have violins, cellos, and percussion. Individually, they are talented. But without a score - a shared piece of sheet music that tells everyone when to play - you just have noise.

Claude Code is the orchestra. Its agents (subagents), commands (slash commands), and skills (specialized domain knowledge) are the instruments.

This repository is the Full Score.

It introduces the Command → Agent → Skill pattern. In this model, you don’t just “prompt” the agent. You invoke a Command (the baton), which coordinates an Agent (the specialist), which uses a Skill (the instrument) to produce the music (the code).

The “Aha” Moment: /weather-orchestrator

I expected this repo to be a list of prompt tips. Instead, I found the Orchestration Workflow.

It uses a weather-fetching example to show something profound: a single slash command can manage multiple contexts. It asks you for your unit preference (Celsius or Fahrenheit), then delegates the “dirty work” of API fetching to a Sonnet-level subagent with a weather-fetcher skill. Once the data is back, it hands it to a lighter Haiku-level “Skill” to render an SVG weather card.

Scenario	The “Vanilla” Way	The Orchestrated Way
New Feature	”Can you add a login page?” + 4 follow-up prompts	`/plan` (interviews you) → `/execute` (TDD-first)
Bug Fix	Paste error log + say “fix”	`/debug` (spins up a “QA subagent” to find the root cause)
PR Review	You read everything manually	`@claude` on PR identifies recurring mistakes for `CLAUDE.md`

Friendly Example: The Professional’s CLAUDE.md

Most people’s CLAUDE.md is a mess of half-remembered rules. This repo teaches you how to treat it as a Living Constitution.

Instead of telling Claude “Always use Tailwind,” you define a protocol:

<!-- From the Best Practice repo -->
<important>
If implementing a UI change: 
1. Use the `ui-specialist` agent via `Agent(agent: "ui-specialist")`
2. Ensure the `PostToolUse` hook runs `npm run lint:css`
3. Never bypass the `/verify-styles` skill.
</important>

It turns a suggestion into a deterministic step in the machine.

Boris’s 13 Tips: Seeing Like an AI

The “hidden” gold in this repo is the collection of tips from Boris Cherny, the creator of Claude Code.

My favorite? “Run 5 Claudes in parallel.”

It sounds insane until you do it. You have one Claude running a 10-minute migration, another exploring the API of a new library, and a third building your UI components. You number your terminal tabs 1–5. You stop waiting for the machine. The machine starts waiting for you.

The Diagnosis: What Changes in Practice

When you adopt these practices, the way you sit at your desk changes.

You stop “babysitting”: You don’t watch the terminal roll. You set a hook (like the PostToolUse hook in the repo) to auto-format your code and run tests, and you go get coffee.
You scale your IQ: You use Subagents for the specific problems where a single context window is too small. You offload the “linting” or the “research” to a fresh context so your main Claude stays sharp.
You build “Instincts”: Every time you find yourself correcting Claude, you don’t just fix it and move on. You update the shared CLAUDE.md. You’re teaching the machine your own “coding vibe.”

The Reality Check: The Cost of Orchestration

Every framework has a tax. If you spend three days building a complex /deploy-orchestrator with five subagents and three skills just to deploy a static site, you’ve lost.

Boris himself notes that his personal setup is “surprisingly vanilla.” He doesn’t over-engineer. He uses what works.

This repo is a menu, not a mandate. You take the orchestration pattern when the project gets too big for one head. You take the parallel terminal tabs when you’re in the “flow state.” You take the shared CLAUDE.md when you start working with a team.