Skip to content
ISSUE #77 • Nov 20, 2026 • 10 MIN READ

The Orchestrate Skill: Teach Opus or Fable to Run a Team of Agents in Any Repo

“Wait… didn’t you write about this before?”

Yes. Three weeks ago, in I Taught Opus 5.5 to Pick the Right Sub-Agent for Every Job.

That post introduced the orchestrate skill: a boss model that plans the work, hands each task to the right sub-agent and checks the result before it lands.

There was one catch. That version needed CloudPlay’s setup.

On a fresh cloud checkout, that setup fits like a glove. In a repo on your laptop, it’s a tuxedo at a plumbing job. Your half-finished edits are lying around, you’re on whatever branch you left open, and you’d rather nothing got pushed yet.

(My laptop repos are rarely tidy. I suspect yours are the same.)

So here’s the news.

There’s now a standalone version: a local Claude Code orchestrator for any repo on your own machine. The skill has also picked up a few new habits since October, and one of them is my new favourite. (More on that later.)

By the end of this post, you’ll know what changes on your machine, how each member of the crew is dialled, and how to install it in two commands.

Whiteboard-style cartoon of a cheerful white robot in a yellow hard hat, with a brown clipboard tucked under one arm and a name badge reading Opus or Fable, climbing down a small wooden ladder from a big fluffy cloud that has a faint building site with scaffolding and a crane sketched on top. The robot carries a red toolbox labelled orchestrate toward an ordinary home desk on the right with an open laptop, a coffee mug and a yellow sticky note reading my repo, and a yellow banner across the bottom reads Cloud boss, local job.

.

.

.

A Quick Recap: The Boss and the Crew

Missed October? Here’s the short version.

The skill runs your Claude Code session like a building site. The boss plans the job, hands out the work and inspects every result, and it’s whichever model your session runs, Opus or Fable. Sonnet is the skilled builder. Haiku is the fast apprentice who runs the errands.

Every task in the plan carries its route right at the front, like [sonnet·medium]. One glance tells you who’s on the job and how hard they’re thinking.

And the line that holds it all together:

“A worker’s ‘done’ is a claim.”

So the boss checks the work itself before it ticks anything off. For the full story (model rankings, escalation ladder and all), head back to the October post.

.

.

.

What Changes When the Boss Works on Your Machine

So what changes when you run a local Claude Code orchestrator instead of the CloudPlay one?

Here’s the side-by-side:

CloudPlay version (Oct 23)Local version (new)
BranchMoves to a feature branch firstWorks on whatever branch you’re on
Your own uncommitted editsNot a concern (fresh cloud checkout)Left out of every commit, listed at the end
PushPushes at the endNever pushes unless you ask
When it loadsFor almost every requestWhen you ask for it (“orchestrate this”, “use sub-agents”)

Here’s what that means in practice:

  • Your half-finished edits stay yours. On a laptop, this is the change that matters most. (I once found my scratch notes file sitting in an agent’s commit, right next to the feature it built.) Before the crew starts, the boss spots files you’d already changed, asks whether to include them in its commits and recommends leaving them out. Its final report lists them as left alone. Picture the foreman sticking a “hands off” note on your coffee mug and notebook.
  • One builder at a time. Scouts can read the blueprints alongside, but anyone who changes files takes a turn at the main workbench, so nothing collides or needs merging back. It’s a little slower, since builders queue. Want parallel builders? Ask for worktrees, which I walked through in How I Vibe Code With 3 AI Agents Using Git Worktrees (Without Breaking Anything).
  • Nothing gets pushed unless you say so. The boss commits its own work on your current branch, and the push stays your call. Ask for one, and it pushes the branch you’re on.
  • It waits to be asked. The local version wakes up when you say “orchestrate this” or “use sub-agents”, so a quick question still gets a quick answer.

CloudPlay stays right where it was. It’s still the way in for Claude Code on the web, where a fresh checkout and a feature branch make perfect sense.

Everything else carries over from October: the routing, the labels and the escalation ladder.

Two-panel whiteboard cartoon of white robots wearing name badges. The left panel, under a blue header reading CloudPlay (cloud), shows a building site on top of a cloud, where the boss robot in a yellow hard hat stands at a desk signed feature branch, three Sonnet robots in purple hard hats work at three separate small desks each signed own worktree, and a blue arrow rises to a small cloud labelled push. The right panel, under an orange header reading Local (your machine), shows one long wooden home workbench signed any branch, where one Sonnet robot builds while two small hatless Haiku robots read a rolled-out blueprint beside it, a coffee mug and an open notebook sit on the corner under a yellow sticky note reading your edits: hands off, a small sign reads no push unless you ask, and the same boss robot with its clipboard and Opus or Fable badge stands at the end of the bench. A yellow banner across both panels reads Same boss. Your machine.

.

.

.

Every Role Gets Its Own Dial

You met the two dials in October. The model decides who does the job, and effort decides how long that worker thinks before it acts.

Since then, the crew has picked up named roles. Each role starts with sensible settings on both dials, like where the dials sit when a worker clocks in. The boss can still pick something different for any task.

RoleWhat it doesStarts at
BossPlans, hands out work, checks every resultYour session’s model: Opus or Fable
ScoutQuick lookups and searcheshaiku·low (or haiku·medium when it mustn’t miss)
BuilderFeatures, fixes, tests, docssonnet·medium (higher, or Opus, for the hard jobs)
ReviewerReads the finished change with fresh eyes; read-onlyopus·high
VerifierTries the app and writes down what it saw; gives no verdictsonnet·medium

(Boss, Scout and Builder are my own nicknames. Reviewer and Verifier come straight from the skill.)

Whiteboard-style cork noticeboard in a wooden frame with five name-badge cards pinned in a row with coloured push pins, each showing a role name, a white robot and a small round effort dial marked low, medium and high. The yellow Boss card shows the robot in a yellow hard hat with a clipboard and an Opus or Fable badge, captioned checks everything, with no dial; the orange Scout card shows a small hatless Haiku robot with a magnifying glass and its dial on low; the purple Builder card shows a Sonnet robot in a purple hard hat holding a trowel with its dial on medium; the yellow Reviewer card shows an Opus robot in a yellow hard hat with a magnifying glass, a tiny padlock on its pen and a read-only tag, with its dial on high; and the teal Verifier card shows a Sonnet robot holding a camera and a notebook, tagged evidence only, with its dial on medium. A yellow banner across the bottom reads Every role gets its own dial.

A few of those starting points are worth a closer look:

  • The boss’s chair. Opus is the tuned default. Run Fable as the boss and the skill mentions once that it was tuned on Opus 5.5, then gets on with the job. Fable as a sub-agent stays opt-in.
  • Why the reviewer starts highest. Reviews are where deep thinking pays off. The reviewer also arrives with a clean slate, so it judges the finished change on its own merits.
  • Why the verifier sits at medium. Its job is to try the app and write down what happened. Judging belongs to the boss, and the skill’s instruction to the verifier is blunt: “Give no pass/fail verdict.” (I do love a worker who knows its lane.)
  • Why Haiku stays on errands. I dug into that in Can Haiku 5.5 Beat Opus 5.5? I Made It Build the Same Game Twice.

Now for the habit I promised, my favourite of the lot: knowing which dial to turn.

When a worker misses, the boss reads its report and asks one question. What kind of miss was this?

  • Did it skip work? Maybe it never opened a file it needed, or never ran the check. Turn effort up a step, so the same worker slows down and does the job properly.
  • Did it try hard and still get it wrong? That calls for a more senior hand, so move up a model.

A builder who skipped the spirit level needs to slow down. One who used it and still built a crooked wall needs the foreman’s best bricklayer.

Whiteboard-style cartoon of a Sonnet robot in a purple hard hat scratching its head beside a task card stamped missed in red, in front of a wooden signpost with two arms. The orange left arm reads Skipped work? and points to a big knob labelled effort with a curved arrow turning it up one notch, while the blue right arm reads Tried hard, still wrong? and points up two wooden steps to an Opus robot in a yellow hard hat waiting at the top to help. On the far side, the boss robot with its clipboard and Opus or Fable badge points at the signpost, and a yellow banner across the bottom reads Read the miss. Turn the right dial.

.

.

.

Tighter Checks Before Anything Lands

The boss has also got stricter about what counts as finished.

  • Every review finding gets graded. The reviewer marks how bad each problem is and how sure it is. The boss fixes the serious, confirmed ones and lists the rest in the report.
  • Defects go back to whoever wrote the code. That worker still has the context. Think of the inspector’s snag list going straight to the builder who laid that wall.
  • “Could not run” gets said out loud. When a check can’t run, the boss reports the task as unverified. It never quietly swaps in a weaker check and hopes you won’t notice.

That last one is personal. I’ve had a sub-agent tell me the tests passed when they never ran at all. The test command had failed to start.

Credit where it’s due: the reviewer and verifier split, and the finding grades, are adapted from Ray Amjad’s task-lifecycle skill (MIT).

Illustrated example of a dark Claude Code panel headed Reviewer [opus·high] · read-only · lens: spec, with an orange Example run (illustration) tag in the corner. It lists three graded findings in monospace columns: a red blocker, confirmed, on the presets endpoint, saying anyone logged in can save presets, with the fix check permission first; an amber should-fix, plausible, on the presets form, saying names are not trimmed and near-duplicates are possible; and a grey nit, confirmed, saying a helper name doesn't match the spec's term. Below a divider, two orange annotation lines read Fix now: #1 → back to the builder who wrote it, and Carry to report: #2, #3.

.

.

.

What a Run Looks Like on Your Machine

Time to watch the whole crew on one job. This run uses a made-up presets feature, so you can see every role at work.

The request. You’re in a repo with two of your own files still uncommitted, and you type:

/orchestrate:orchestrate Add a "presets" feature per docs/spec.md. Use sub-agents.

Preflight. First, the boss checks the repo, spots your two files and asks what to do with them.

Illustrated example of a dark Claude Code terminal panel with an orange Example run (illustration) tag in the corner. The top half shows orchestrate preflight output reading BRANCH=main, TREE=dirty (2 paths), a modified notes.md and an untracked scratch.txt, and RESULT=ok. The bottom half shows a question box with an orange left border asking whether the 2 files already changed before this run, notes.md and scratch.txt, should be included in this run's commits, with the first option, Leave them out (Recommended), highlighted in orange above a plain second option, Include them.

Leave them out is the recommended answer, and the one I’d pick. (Ask me how I know.)

The plan. Next comes the task list: seven labelled tasks covering every role. Scouts go first, then the builders take turns at the bench. The tricky timing bug gets Sonnet at high effort, the review runs on Opus at high, and the verifier goes last.

Illustrated example of a dark Claude Code task list with an orange Example run (illustration) tag in the corner and seven rows, each with a thin coloured role bar on its left edge. Three done rows with green checks read #1 [haiku·low] Find the settings loader (scout), #2 [haiku·medium] Which files register routes? (scout) and #3 [sonnet·medium] Add the presets endpoint (builder); an in-progress row with an orange square reads #4 [sonnet·medium] Add presets to the settings form (builder); and three pending rows read #5 [sonnet·high] Fix the preset sync timing bug (builder), #6 [opus·high] Review the change against the spec (reviewer) and #7 [sonnet·medium] Try the presets flow, record what happens (verifier). The role bars are orange for scouts, purple for builders, yellow for the reviewer and teal for the verifier.

The report. When the dust settles, the boss commits only the run’s own files on your current branch and pushes nothing. The report shows which model ran each task, how each one was checked, and your two files, left exactly where you put them.

Illustrated example of a dark Claude Code panel with an orange Example run (illustration) tag in the corner, showing a rendered Run report table with the columns Task, Ran on and Checked how. Its rows read: #1–#2 scouting, haiku, spot-checked; #3 presets endpoint, sonnet·medium, tests pass and review fix; #4 settings form, sonnet·medium, tests pass; #5 sync timing bug, sonnet·high → opus·high, tests pass; #6 review, opus·high, 1 fixed and 2 carried; and #7 try the flow, sonnet·medium, boss read the evidence. Below the table, a green-ticked line reads Committed on main (not pushed), and a second line reads Left uncommitted: notes.md, scratch.txt (yours, from before the run).

Spot task five? In this example, Sonnet gave it everything at high effort and still missed, so the boss called in Opus. Read the miss, turn the right dial.

.

.

.

Install It in Two Commands

Ready to hire a boss of your own? Here’s how to set up the local Claude Code orchestrator. Inside Claude Code, add the marketplace and install the plugin:

/plugin marketplace add nathanonn/agent-skills
/plugin install orchestrate@nathanonn-agent-skills

Then, in a fresh session, hand the boss a job:

/orchestrate:orchestrate Build the feature described in docs/spec.md with sub-agents

Prefer the skills installer? This one line works instead:

npx skills add nathanonn/agent-skills --skill orchestrate

Pick one route only. Two copies of the skill would both answer the call, each with its own rules.

Two quick notes:

  • One copy only. If you copied the CloudPlay version into a repo earlier, remove it first.
  • Start a fresh session after installing, with Opus or Fable as your boss. New skills load when a session starts.

Optional settings live in the repo’s README. The plugin is at version 1.1.0, it’s MIT-licensed, and you’ll find it at github.com/nathanonn/agent-skills.

Working in Claude Code on the web instead? CloudPlay is still the place to start.

.

.

.

Your Turn: Give Your Own Repo a Boss

If you take one thing from this post, make it this.

With the orchestrate skill, choosing a model and an effort level for every task stops being your job. You hand the boss the playbook, and it works out who does each task and how hard they think.

The usual advice is to switch the model or the effort yourself, task by task. For me, that’s too much work on the human side.

I tried switching models and effort by hand for a while. More than once I forgot to switch back and had Opus on high effort fixing a typo. (Fiddling with dials all day is a strange way to run a building site.)

In the age of AI, your attention is worth more than ever. Spend it on what needs building and why. Hand the how — and the whole process of building it — to the AI, and save yourself for the high-level calls that really matter.

In October, the boss ran a building site up in the cloud. Now it has climbed down to the job that’s already open on your laptop, half-finished edits and all.

Here’s your challenge: pick a real multi-step change in your own repo and run it. Then pause and read the first plan before anything gets built. It’ll tell you a lot about your new boss.

Wondering where this sits in the bigger picture? I mapped it out in The 4 Levels of Agentic Coding (And How to Climb to the Next One).

👉 Install the plugin and reply with the first plan your boss writes.

The boss has come down from the cloud. Your laptop is the building site now, so grab a hard hat.

Nathan Onn

Freelance web developer. Since 2012 he’s built WordPress plugins, internal tools, and AI-powered apps. He writes The Art of Vibe Coding, a practical newsletter that helps indie builders ship faster with AI—calmly.

Join the Conversation

Leave a Comment

Your email address will not be published. Required fields are marked with an asterisk (*).

Enjoyed this post? Get similar insights weekly.