Turning Claude Code Into a Multi-Agent Orchestrator

How a simple skill unlocks Opus, Sonnet, and Haiku for complex code changes without burning your context (or your patience).

Why I built an orchestrator skill

If you use Claude Code everyday and you tried to push a complex refactor or multi-file feature through a single Claude Code chat, you’ve probably had my same existencial question. Should evoke the trust-worthy Opus, or maybe just sonnet can do it? I honestly found myself writing a plan with opus to make sure my specs are followed correctly then switched context to sonnet for the implementation (when everything was well laid down) to spare some subscription usage.

Since I grow tired of always doing this manually I wrote a skill that does it all automatically.

The plan-orchestrator skill splits one big implementation into multiple sub-agents: an orchestrator that plans and reviews, implementation agents that actually touch the code, and a “monkey” agent that only runs commands and returns condensed outputs. Each layer is tuned to a different model: Opus for planning, Sonnet for implementation, Haiku for cheap, noisy tasks like linting and test runs.

How the skill organizes the work

The orchestrator stays focused on three things: understanding the current state of the repo, closing ambiguities with a few targeted questions, and writing a proper plan that breaks the work into sub-tasks with dependencies. It never touches the code directly. Instead, each sub-task is handed off to a fresh implementation sub-agent with just the context it needs and a clear mini-spec. This is the most complex and important part of the work. What is worth disturbing Opus for.

Those implementation agents follow instructions verbatim, make the code changes, run any necessary housekeeping (builds, tests, lint), and then report back in a strict template: what they changed, how it meets the spec, what checks they ran, and whether they are completed or blocked. If they hit something ambiguous: a missing requirement, a risky decision, or a failing test that needs trade-offs — they escalate back to the orchestrator instead of guessing. This level of work is perfect for a cost-effective model like sonnet.

The “monkey” agent is even simpler: it never edits source, only runs commands and returns summarized outputs so logs and stack traces don’t flood the other agents contexts. This keeps the orchestrator’s view clean and makes it easier to decide the next step.

Why this works better than “just chat”

On a mid-size repository, a 45‑minute run with this skill turned into a session where Opus designed the plan, Sonnet handled the real code work, and Haiku ran all the repetitive commands, with a high cache hit rate and a very predictable cost profile. Instead of one huge conversation where everything is mixed together, you get a sequence of focused sub-tasks that are more efficient and effective.

Usage and cost dashboard

Because each implementation agent works in a clean context, you avoid the “forgotten requirement” effect that often happens when the model is juggling too many concerns at once. And since every sub-task ends with a structured report, you can scan the whole run afterward like a mini change log: what changed, what passed, and what still needs a human decision.

If you’re using Claude Code heavily, this skill turns its multiple models into a real workflow engine instead of a single, overloaded chat window. The orchestrator keeps the big picture, the implementation agents do the focused work, and the monkey keeps your logs under control, all from one initial request.

The comparison that seals the deal

To see if the orchestration actually paid off, I ran the same type of task twice: once with the skill handling the multi-agent split, and once with a single Opus agent working alone without any orchestration. The skill-driven run cost 1.11 dollars against 1.38 dollars for the Opus-only run, finishing in 7 minutes instead of 9, while also keeping a lower peak context (71,584 versus 76,026 tokens).

Cost and usage comparison for task with and without skill

The advantage isn’t just financial. By spreading sub-tasks across different models, total time drops because simple operations like commands, checks, housekeeping, no longer have to go through an expensive, slower model like Opus for every single step.

How to get it

In the technical deep dive on my blog (here), you’ll find the full setup: the GitHub gist with the skill file and a bot‑oriented prompt you can use have claude install the skill by itself.

If you want to try the skill right now just paste this prompt into claude then active the skill with /plan-orchestrator:

Open and read the technical article at this link: https://danipisca07.github.io/blog/plan-orchestrator-skill. The article describes a “plan-orchestrator” skill that turns Claude Code into a multi-agent system using different models. Download the SKILL.md file locally in the skill folder and install the skill locally so I can use it whenever I want with the /plan-orchestrator command.