Skip to content

Category: The Art of Vibe Coding

• 10 min read • The Art of Vibe Coding

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

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.

• 10 min read • The Art of Vibe Coding

How to Generate Unlimited Images With gpt-image-2.6 (Sort Of)

How to Generate Unlimited Images With gpt-image-2.6 (Sort Of)

I’ve been sitting on this one for a while, because I really don’t want OpenAI to close the loophole that allows for (kinda) unlimited image generation with gpt-image-2.6.

There. I said it.

(If anyone at OpenAI is reading this, please skim.)

Back in June, I wrote Generate Images in Claude Code — Without Even Asking for a Command. It covered a skill that lets Claude Code borrow Codex’s built-in image tool. Ask in plain English, and a real picture lands in your project.

That post skipped one thing.

The bill.

Every image I make with gpt-image-2.6 in Codex comes out of my ChatGPT plan. Since June, I’ve found a way to make each one take a much smaller bite of it.

By the end of this post, you’ll know what an image really costs on your plan — and you’ll have one small setting in place that makes every image far cheaper.

Fair warning, though.

“Unlimited” carries an asterisk. I’ll show you exactly where it sits. That’s the “sort of” in the title.

A cartoon developer holds a finger to their lips beside a gap in a tall fence, where a stack of framed gpt-image-2.6 pictures spills out and the small Claude Code robot peeks through. The banner reads "The quiet loophole."

Let’s start with the price tags.

.

.

.

Two Price Tags for One Picture

A gpt-image-2.6 picture has two prices, and which one you pay depends on the road you take to make it.

Road One: The API

OpenAI publishes token rates for its image models, so a per-image price has to come out of the token calculator in OpenAI’s image generation guide. Run a typical blog image through it, at medium or high quality, and you get roughly 3 to 5 cents an image.

Typical blog imageApprox. cost per image
Medium quality, 1536×1024≈ $0.034
High quality, 1024×1024≈ $0.053

At that rate, 50 images a week through the API comes to about $8 to $12 a month.

Hold that thought. We’ll come back to it.

Road Two: Codex on Your ChatGPT Plan

The second road runs through the plan you already pay for.

When you generate with gpt-image-2.6 in Codex, there’s no separate image counter. Images count toward the same usage limits as your normal turns. Then OpenAI’s Codex pricing FAQ drops the line this whole post hangs on:

Image generations “use included limits 3-5x faster on average than similar turns without image generation, depending on image quality and size.”

So an image is simply a more expensive turn, drawn from the same pool your coding turns use. One tank, two hoses — and the image hose is the thick one.

Chat turns and image turns both feed a single plan gauge labelled "your plan", with the image hose drawn thicker and tagged x3–5, while an empty dashed outline beside it is labelled "Image meter?". The banner reads "One plan. No image meter."

Stay with me, and follow that logic one step further.

If an image is a turn times three to five, the size of the turn decides the price.

And the size of the turn? You control that.

That’s the loophole.

.

.

.

The Loophole: Put the Multiplier on a Cheap Turn

The 3–5x multiplier applies per turn, and a turn’s cost depends on the chat model running it.

Think of it like surge pricing. A 3x surge on a limo ride stings. On a bus fare, you’d barely notice.

During an image run, the chat model barely lifts a finger. It passes a prompt to Codex’s image tool, and the image model draws the picture.

So the cheapest chat model you have can do the job.

If the Sol and Luna tiers are new to you, GPT-5.6 Sol Is Way Better in Claude Code (Here’s How to Set It Up) covers them: Sol is the heavyweight, and Luna is the quick, light one.

You already know API prices, so here’s the gap in those terms, from OpenAI’s API pricing page (standard tier, per 1M tokens, fetched 2026-11-11):

ModelInputOutput
GPT-6 Astra$10.00$50.00
GPT-6.1 Sol$2.00$10.00
GPT-6 Luna$0.10$0.50

Per token, GPT-6 Luna is 20x cheaper than Sol and 100x cheaper than Astra. Three to five times a small number is still a small number.

One hedge. OpenAI says API prices don’t map exactly onto plan usage, and it publishes no images-per-plan figure, so treat the ratio as a rough measure of the gap.

A towering stack labelled Sol stands beside an ankle-high stack labelled Luna, each topped with the same x3–5 bracket and the same framed picture, while the Claude Code robot compares them. The banner reads "Same picture. Cheaper turn."

Nothing here is hidden. OpenAI documents every piece on its own pricing pages.

Most people simply never change the model behind their image runs, so they pay the expensive rate by default.

Hence the “sort of”.

.

.

.

“But It’s Only 4 Cents”: Why Volume and Friction Win

I can hear the objection already.

“Hang on. An API image costs about 4 cents. Fifty a week is $8 to $12 a month. Why bother?”

Fair point. That is cheap.

Here’s the thing, though. Nobody makes one image per post. Mine add up like this:

  • Five featured-image variations, so there’s a real choice
  • Re-rolls when a variation misses
  • Edits and small fixes on the keeper
  • Inline illustrations for the key points

One post quietly turns into a dozen images or more.

On the API, every re-roll is another line item. And line items have a sneaky side effect: they nudge you to settle for the second-best picture.

I know, because I’ve done it. Back when I paid per image through the API, I once kept a featured image I didn’t love. One more re-roll would have cost a few cents, but watching the line items pile up made me call it good enough.

(A few cents. I still wince.)

On your plan, a re-roll on Luna takes a sliver of an allowance you’ve already paid for. So you keep going until the picture is right. You also skip the API key, and a heavy week can’t end in a surprise invoice.

A single blog post page fans out into a growing grid of pictures labelled "5 options", "re-rolls" and "inline", while a plan gauge at the far right stays almost full. The banner reads "One post is never one image."

👉 The limit that matters here is your usage allowance, and on Luna that allowance goes a long way.

That’s what “unlimited (sort of)” means.

.

.

.

Case Study: My Weekly Blog Images, All on Luna

Let me show you how this runs in my own week.

Once a post is written, I ask Claude Code for five featured-image variations in my house whiteboard style, with three earlier featured images as references. After I pick a favourite, I ask for inline illustrations for the key points.

The skill hands each request to Codex. Codex runs the turn on Luna at max effort, and the files land in the post’s images folder. A run takes two to five minutes, so I queue them up and keep writing.

(A tiny illustrator in the next room, basically.)

A developer at a laptop asks for 5 featured images; the request passes from Claude Code to the skill, then to Codex running on Luna, and a fan of finished pictures lands in an open folder. The banner reads "Ask once. Images land in your folder."

Two recent posts show what that adds up to:

So about 15 runs a post, re-rolls included, every week.

And I’m on ChatGPT Plus. The cheapest paid tier.

What the Meter Said

For this very post, I measured it.

I opened the plan limits panel in ChatGPT, generated the seven illustrations you’re looking at on Luna at max effort, with no re-rolls, and checked again. The 5-hour limit went from 98% left to 95% left.

When the panel showed 95%, I closed it and opened it again. I assumed it just hadn’t caught up yet.

It had.

About 3% of one 5-hour window.

Codex Plan limits panel before generating, with the 5-hour limit at 98% left

The meter rounds to whole percentages, and this is one batch on one plan, so I won’t stretch it into a promise about how many images you can make.

Re-Rolls Are Cheap

For the orchestrator post, the CloudPlay stack illustration took three tries, and the meter barely twitched.

In the 4 Levels post, the generator drew the small corner badge a little differently on every image. So I made one badge and pasted it on by hand, like a kid with a sticker sheet.

Cheap retries buy you plenty of attempts. Pixel-perfect consistency still sometimes needs a manual fix.

Does the Cheap Model Hurt the Picture?

Fair question.

Luna only handles the generation step. The prompt itself can come from a much better model.

That’s how this post was made. Claude Code, running Opus 5.5, wrote every image prompt. Luna’s only job was to call the image model and pass that prompt along.

The smart model writes, and the cheap model delivers. That split is exactly what the skill sets up, and so far I’ve never needed Sol for an image.

Every illustration in this post came out of this routine.

Which means you’ve been looking at the demo all along.

.

.

.

Set It Up Once: One Small File

Here’s the how-to. It takes about two minutes.

Step 1: Install the Skill

  • Claude Code: add the marketplace with /plugin marketplace add nathanonn/agent-skills, then run /plugin install codex-imagegen@nathanonn-agent-skills
  • Other agents: npx skills add nathanonn/agent-skills --skill codex-imagegen
  • Codex CLI (now required): npm i -g @openai/codex, then codex login with your ChatGPT account. If Codex runs on an API key instead, API pricing applies.
  • Where the skill lives: nathanonn/agent-skills, now at version 1.1.1

A quick correction for June readers: the skill now needs the Codex CLI, so install it even if you already have the Codex plugin.

Step 2: Add the Machine Profile

This is the step that matters.

One small file decides which model runs gpt-image-2.6 in Codex for you. It sets the model for image runs only, and the rest of your Codex work keeps its usual model.

Without it, image runs use whatever your current default Codex model is.

I learned this one the hard way. Before I set up the profile, my image runs went through whatever big model I’d been coding with, and my 5-hour window drained far faster than a few pictures should allow.

If that default is GPT-6 Astra, every image turn costs an arm and a leg, at 100x Luna’s per-token price. On Plus, that adds up fast.

# ~/.codex/imagegen.config.toml
model = "gpt-6-luna"
model_reasoning_effort = "max"

That’s it.

Every image run now goes through GPT-6 Luna at max effort.

A large dial labelled "Image runs" points to Luna, with a small file pinned to it labelled "one small file" and a side lever for switching a single image to Sol. The banner reads "Set it once."

Step 3: A Few Handy Extras

Worth knowing, the skill can also do these:

  • One image on Sol: ask Claude Code to “use gpt-6.1-sol for this one”, or pass --model gpt-6.1-sol on that run
  • Effort: Luna runs from low to max, and a lower effort should stretch your limits further
  • Dry run: prints which model and effort will be used, which also catches a typo in the file
  • Model names: list the current ones with codex debug models

.

.

.

A Cheap Turn, a Full Images Folder

So, back to my confession.

The trick was sitting in OpenAI’s own docs the whole time. An image is a turn times three to five, and almost nobody changes the model behind that turn.

One small file fixes that. From then on, the plan you already pay for starts covering a lot more pictures.

There’s one wrinkle on the horizon, though. Starting in December, ChatGPT and Codex will share one usage pool, and OpenAI hasn’t said yet how images will count under it.

A wall calendar flipped to December stands beside separate ChatGPT and Codex gauges whose arrows merge into one bigger gauge, with a sticky note on the calendar. The banner reads "Use it while it lasts."

So here’s your next move. Install the skill and add the profile. Then make your next featured image on Luna, and re-roll it until it’s right.

Use it while it lasts.

• 15 min read • The Art of Vibe Coding

The 4 Levels of Agentic Coding (And How to Climb to the Next One)

The 4 Levels of Agentic Coding (And How to Climb to the Next One)

You open Claude Code, type a request and hit enter.

Quick question. How big was that request?

Be honest.

(Nobody’s watching.)

Most of us hand Claude Code roughly the same size of job every time. A form here, a feature there. That size crept in by habit and stuck around — like the route you drive to work without ever having decided on it.

Yet that habit quietly sets the pace of your whole day. It decides how often you get dragged back into the chair, and how far you can trust whatever comes back.

So here’s the idea this whole post hangs on:

In agentic coding, the setting you control most is how much work you hand over in one request, and who checks the result.

Hold onto that. Everything below builds on it.

To make it concrete, we need a project.

Imagine you’re building an all-in-one SaaS for coworking spaces. Owners manage memberships and passes, members sign up for packages, and the app covers everything a coworking space needs to run the business. We’ll carry this imaginary app through every section that follows.

(Imaginary, so the coffee is free.)

And there’s a ladder to climb.

It has four levels, plus one rung underneath that most of us start on. By the end of this post, you’ll know which rung you’re standing on — and the one piece of setup that lifts you to the next.

A cartoon developer shades their eyes and looks up at a tall wooden ladder whose five rungs are each hidden behind a yellow sticky note with a big question mark, while the small white Claude Code robot looks up beside them. The banner reads "How high can you climb?"

Let’s start at the bottom.

.

.

.

Level 0: The Micromanager (Where Most of Us Start)

Let me show you what Level 0 sounds like in our coworking app:

“Create the sign-up page.”

“Add a form with name, email, password and confirm password.”

“Now write the server code for sign-up.”

Three requests.

Every one of them is a step the AI could have worked out by itself.

At Level 0, you treat a capable agent like an intern who needs every keystroke spelled out. Meanwhile you sit in the chair for the whole thing, waiting to dictate the next line — a bit like reading turn-by-turn directions aloud to a driver who already has the map open.

Honestly?

It’s a bit of an insult to AI.

A grinning developer shouts into a megaphone at the white Claude Code robot, with speech bubbles reading "Add a form", "Now a password field" and "Now the server code". The robot waits with its hands folded and imagines a finished sign-up page under the words "I can do the whole thing", above the banner "Stop dictating every step."

If that sounds like you on a bad day, relax. Most people start here.

The fix is easy.

Ask for the whole feature. (It can handle it.)

That’s Level 1.

.

.

.

Level 1: You Are the Tester

  • You ask for: one whole feature
  • In the coworking example: “Create sign-up with email and password auth.”
  • Who tests: you, by hand
  • Where you sit: in the loop after every change
  • Setup: nothing

The loop is simple.

The AI builds the sign-up feature. You open the app and try it. If it works, you move on to the next feature. If something breaks, you describe what went wrong and ask for a fix.

Round and round — until the feature finally does what you want.

The Claude Code robot hammers together a "Sign-up" form while a tired developer clicks through it at a laptop, with one arrow leading to "Works? Next feature" and another looping back through "Broken? Ask for a fix". The banner reads "You are the tester."

If that loop feels familiar, there’s a reason.

This is how AI coding worked back in 2024 and early 2025, in Cursor’s Composer days. You asked for a feature, tested it yourself, and asked for a fix when it broke.

Plenty of people still work this way today.

Meanwhile, Claude Code and other agent harnesses can now test and fix their own work.

To be fair, Level 1 still suits quick fixes and experiments.

The ceiling shows up once you build something bigger. You become the bottleneck. Every change waits for you to click through it, and you run out of steam long before the AI does.

I’ve lost whole evenings clicking through the same form, describing the same bug in slightly different words, while the AI waited patiently for my next report.

One pointer while you’re here.

When you’re the tester, the quality of your bug report decides the quality of the fix. Think of describing a strange noise to a mechanic: a recording beats your best “kind of a clunk-clunk” impression every time. So show the AI what you see — the screen, the error message, the exact steps that got you there. I covered this in Stop Arguing With Your AI. Start Showing It What You See.

The next rung takes you out of the testing altogether.

.

.

.

Level 2: Hand Over the Testing

  • You ask for: still one feature
  • In the coworking example: the same sign-up feature
  • Who tests: the AI, against a test plan
  • Where you sit: approving the spec
  • Setup: a spec, a test plan, a reusable test script and a browser the AI can drive

Same feature as Level 1.

Stay with me, because one big change reshapes the whole day: you give the AI a goal it can reach and check by itself.

Here’s the flow:

  1. The AI writes the spec for the feature.
  2. From the spec, it writes a test plan and an implementation plan.
  3. It builds the feature.
  4. Then it runs the test plan to check its own work.
  5. When a test fails, it fixes the feature and runs the tests again, until everything passes.

For the spec, I use the approach from The 3-Phase Method for Bulletproof Specs When You’re Not Starting From Scratch. For turning that spec into a test plan and an implementation plan, see How to Make Claude Code Actually Build What You Designed.

Look at where you sit now.

You read the spec and approve it, and the AI carries everything after that. (Quite the promotion. Yesterday you were the one clicking buttons.)

Three things make this work in practice.

Test the whole flow in a real browser

Behind-the-scenes checks on the code can all pass while sign-up is still broken for a real person. Green lights on every dial, and the front door still jams.

So give the AI a browser it can drive, such as Playwright. Then it tests the way a user would: it fills in the form, hits submit and confirms it lands logged in.

I saw this pay off in How to Make Claude Code Test and Fix Its Own Work (The Ralph Loop Method). The loop tested each case in an actual browser and caught bugs Claude had missed during the build.

Keep the builder and the checker separate

An agent pushed to pass will sometimes find a way to pass. For example, it might work backwards from the expected answers.

(Clever. Also useless.)

I’ve watched an agent “pass” by quietly bending a test to fit its code. Every box ticked, feature still broken.

So a separate checker sub-agent gets the final say on whether the feature passed. The builder builds, and the checker decides.

One hard rule covers every agent in the run: never edit the tests to make them pass.

Two Claude Code robots work side by side: a "Builder" in a yellow hard hat assembling a sign-up form, and a "Checker" with a magnifying glass beside a browser showing a ticked "Logged in?", with a red "Fails? Fix it" arrow running back to the Builder. Between them stands a padlocked "Test plan" with a sign saying "Never edit the tests", while a developer stamps a "Spec" page "Approved" above the banner "A separate checker decides."

Build the test script once, and reuse it

Without a shared script, every agent writes its own throwaway way to start the app and sign in. Each one does it a little differently. It’s slow, and it burns context.

(Picture every new member of a coworking space cutting their own key to the front door.)

Turn the mechanical parts into one shared script that every agent uses (starting the app, signing in as an owner or a member, taking screenshots). Then the AI only has to handle the parts that need judgement.

Three quick ones

  • Match the model to the step. Your strongest model writes the spec and the plans, and a cheaper one writes the code. I tried a strong boss with cheap workers in Can Haiku 5.5 Beat Opus 5.5? I Made It Build the Same Game Twice.
  • Ask for proof. Screenshots or a recording of the flow turn your review into a one-minute job.
  • Turn the effort up. Low effort tends to miss edge cases like a duplicate email or a mismatched password.

Now you approve the spec, glance at the proof, and the testing loop runs without you.

That’s a real shift in where your evenings go.

Next up: handing over more than one feature at a time.

.

.

.

Level 3: Hand Over a Whole Module

  • You ask for: one module
  • In the coworking example: the whole authentication module (sign-up, login, forgot password, reset password and email verification) in one go
  • Who tests: the AI, with one test plan per feature, plus re-checks of what’s already built
  • Where you sit: between modules
  • Setup: everything from Level 2, plus a slice plan and a fresh context per feature

Five features. One request.

The AI builds the whole module, checks each feature against its own test plan, and keeps fixing until every feature passes. Then you point it at the next module — memberships — and off it goes again.

You’ve stepped back from every feature to every module.

Here’s what keeps a run that size on track.

Build in thin slices

Left alone, AI tends to build one layer at a time. It finishes the whole database before it touches anything a person would see, so nothing can be tested until the very end. (It’s like baking every layer of a cake before anyone gets to taste the flavour.)

A better order is one thin slice at a time, cut through every layer. Get sign-up working all the way through, tests included, before login starts.

Then mark each slice in the plan. Some are “AFK” slices the AI can finish alone — away from keyboard, so go make a coffee. Others need you, such as a design decision or an API key.

On the left, under "Layer by layer", the Claude Code robot works only on the bottom "Database" layer of a cake topped by "Server" and "Screens", beneath a note reading "Test it? Not yet". On the right, under "Thin slices", the same layers are cut into "Sign-up", "Login" and "Reset password" slices tagged "AFK", "AFK" and "Needs you", with the finished Sign-up slice ticked green and the banner reading "One thin slice at a time."

Give each feature a fresh context

Run each feature’s building and testing in its own sub-agent or session.

It’s the same move I made for testing in I Showed You the Wrong Way to Do Claude Code Testing. Let Me Fix That., where each test got its own sub-agent and a clean context.

Why bother?

In my experience, output quality drops noticeably once a session gets past roughly 40% of the context windows. A fresh context for each feature keeps every run well clear of that point, and keeps the AI from getting overwhelmed. Think of it as a clean desk for every job.

Re-check what’s already built

After each new feature passes, have the AI re-test a few earlier features at random.

Adding reset password shouldn’t quietly break login — and a quick spot check is how you find out before your members do.

Two more reads, if you want them. For watching how full your main session is getting, there’s I Kept Forgetting to Check My Context. Now Claude Code Reminds Me. And for handing each job to the right sub-agent, see I Taught Opus 5.5 to Pick the Right Sub-Agent for Every Job.

Once whole modules pass on their own, one rung is left. It hands over the whole product and moves your job to the edges.

.

.

.

Level 4: Hand Over the Whole Product

  • You ask for: the whole product, in phases
  • In the coworking example: the full coworking SaaS
  • Who tests: the AI while it builds; then you and separate checker agents, in staging (a private test copy of the app that real customers never see)
  • Where you sit: at the start (requirements and prototype), at a few checkpoints during the build, and at the end (acceptance)
  • Setup: everything from Level 3, plus a requirements interview, a prototype and a staging environment

Here’s the shape of the run.

You and the AI agree the requirements. The AI writes the test plans, then builds module by module in phases, so it never takes on everything at once. Along the way, it tests its own work.

You show up mostly at the start and the end. The bookends.

That only holds up with a few habits in place.

Make the requirements an interview

Have the AI question you in rounds until nothing is left undecided: who the users are, how pricing works, what happens when a pass expires.

Questions that depend on earlier answers wait for them. There’s no point pricing passes before you’ve decided which pass types exist.

By the last round, you’re mostly confirming — like a waiter reading your order back to you.

If something’s unclear, ask the AI to explain it more simply, or to build a quick prototype that shows you.

This is where most of your time should go. I walked through the method in How to Write Better Requirements with Claude (Stop Letting AI Assume), where I had Claude interview me until it was 95% confident. (Fun fact: that post’s example was a coworking-space WordPress theme. Coworking spaces keep turning up on this newsletter.)

Got product docs already? Give the AI access, and ask it to flag anything that contradicts what you’re asking for.

Prototype first, so you avoid a “Frankenstein”

Build the screens one feature at a time and you risk a Frankenstein: parts stitched together that never quite match.

I’ve shipped a plugin where each screen looked like it came from a different app, because I designed them one feature at a time. (Lesson learned.)

So once the requirements are agreed, build a complete, clickable prototype first.

Start from the customer. Who are they, what are they trying to do, and do they need a web app, a mobile app or both? Design every screen. Then derive the build plan and the phases from those designs.

Prototype wherever your taste matters, because a written spec is too abstract to capture it.

My rule of thumb: aim to be about 90% happy with the prototype before you hand it over. Claude Design can pass a design straight to Claude Code, which makes that handoff easy.

The prototype-first idea comes from The Missing Step That Makes AI-Built WordPress Plugins Look Professional. If you’d like to see Claude Design in action, I used it to build a page from a design spec in I Taught Claude to Steal (Ethically) a Design System I Actually Like.

Spend as much effort checking as building

When the build finishes and every test passes, the checking starts. (Yes, right about when you’d like to pop the champagne.)

Deploy to staging and run a final verification pass:

  • Try it yourself. Walk the main flows as an owner and as a member.
  • Ask for a guided tour. Have the AI write a step-by-step walkthrough that opens the app, loads sample data, and tells you what to click and what you should see. Include edge cases, such as a member buying a day pass, a member whose pass has expired, and a failed payment.
  • Send in separate checker agents. Point them at the newest features and the earliest ones, to catch anything that broke along the way.
  • Review every change. Have agents look over everything that changed, flag the risky parts such as payments and permissions, and write extra tests for them.

Expect this pass to cost as many tokens as the build, or more. That’s my rule of thumb, and it’s the price of trusting a build you didn’t watch.

The reality check: you still own the vision

AI is very good at building features and fixing bugs.

Deciding which features are worth building is still a human call.

Yours, specifically.

So your job at Level 4 is the product decisions. The requirements and the prototype are where your taste goes in.

Expect some involvement in the middle, too. Going fully hands-off from requirements to finished product can work for a proof of concept. My overnight run in Can Sonnet 5.5 Really Build a Full Game From One Prompt? I Tested It. was exactly that kind of run: one prompt, overnight.

For a real product, plan a few checkpoints during the build where decisions come back to you.

A road runs from a sign reading "Start: requirements + prototype", where a developer and the Claude Code robot sit under the question "Who are the users?", past robots building "Phase 1", "Phase 2" and "Phase 3" and two "Checkpoint" flags, to "End: check + accept", where the developer holds a clipboard outside a "Staging" building while two robots inspect it. The banner reads "You own the vision."

Aim for the fewest decisions that still give you the most control.

.

.

.

Find Your Level, Climb One Rung

Here are the four levels of agentic coding side by side, with the Level 0 habit underneath them.

LevelYou ask forWho testsWhere you sitWhat you add
0One step at a timeYouDictating every stepNothing (drop this habit)
1One featureYou, by handAfter every changeNothing
2One featureThe AI, against a test planApproving the specA spec, a test plan, a reusable test script and a browser the AI can drive
3One moduleThe AI, one test plan per feature, plus re-checksBetween modulesLevel 2, plus a slice plan and a fresh context per feature
4The whole product, in phasesThe AI while building; then you and separate checker agents in stagingAt the start, a few checkpoints, and the endLevel 3, plus a requirements interview, a prototype and a staging environment

Each rung keeps everything from the rung below and adds one thing. That’s why climbing one rung at a time works.

A tall wooden ladder with five coloured rungs labelled from the bottom "0 Dictate every step" (crossed out, with a "Skip this one" note pointing at it), "1 You test", "2 AI tests a feature", "3 AI builds a module" and "4 AI builds the product", with the Claude Code robot carrying a bigger load beside each rung. A developer climbs between rungs 1 and 2 above the banner "Climb one rung at a time."

So where are you right now?

Pick the line that sounds most like your week:

  • Telling the AI which field to add next (Level 0)
  • Every change waits for you to click through it (Level 1)
  • The AI tests each feature, and you still hand them over one at a time (Level 2)
  • Whole modules pass on their own, and a whole product feels within reach (Level 3)
  • Most of your time goes into the start and the end (Level 4)

Found it? Here’s your one next step:

If you’re atYour one next stepRead
Level 0Ask for the whole feature, and show the AI what you see when it breaksStop Arguing With Your AI
Level 1Write a test plan and give the AI a browser to run itThe Ralph Loop Method
Level 2Plan thin slices and give each feature a fresh sub-agentThe Wrong Way to Do Claude Code Testing
Level 3Let the AI interview you for the requirements, then prototypeHow to Write Better Requirements with Claude
Level 4You’re at the top. Keep your checkpoints, and put your time into the requirements and the checking—

Climb one rung at a time.

Here’s the thing about ladders: the rung you’re standing on is what holds you up while you reach for the next one.

👉 Each rung’s setup is what makes the next one safe to stand on. Agentic coding rewards small climbs: one rung, one new piece of setup.

So, which level are you at today?

If you’re reading this in your inbox, hit reply and tell me. I’d love to know where you’re standing on the ladder.

(Level 0 confessions are welcome. I won’t tell.)

• 6 min read • The Art of Vibe Coding

I Kept Forgetting to Check My Context. Now Claude Code Reminds Me.

I Kept Forgetting to Check My Context. Now Claude Code Reminds Me.

I know the rule.

I wrote a whole post about it.

Watch the context number. When it crosses your threshold, write a handoff doc, then compact.

Sounds tidy.

Then a real build session gets going, and that little number fades into the furniture. By the time I glance down, I’m well past the point where I meant to stop.

In Stop Losing Work When You Compact Claude Code (The Handoff-Doc Skill), the workflow was simple. Watch the context percentage, run the handoff-doc skill at your threshold, then compact. The skill made the writing easy. The watching was still my job, and mid-flow I’m hopeless at it.

So I built a Claude Code context alert that does the watching for me.

It’s a mod called Context Alert.

A mod is a small add-on that plugs into Claude Code itself — the same kind I used in Your AI Agent Can See Your Passwords. Here’s How to Fix That. When you hit your threshold, it taps you on the shoulder and asks what you want to do.

The first time it fired, I was deep in a long build session with a job running in the background. I hadn’t looked at the context number in over an hour. (Of course I hadn’t. That’s the whole problem.)

It’s version 0.1.1, so please treat it as a beta.

The quick version: Context Alert watches your context window and stops you at the percentage you pick. It asks whether to write a handoff doc, compact, or both, and your background jobs keep running through all of it. Install it with three commands, then set your number with one more.

.

.

.

Install it and pick your number

Run these inside a Claude Code session:

/plugin marketplace add nathanonn/agent-skills
/plugin install context-alert@nathanonn-agent-skills
/reload-plugins
/context-alert

Choose user scope when it asks.

That way the Claude Code context alert works in every project, and the last command shows you its status.

Out of the box, the alert fires at 40% of your context window. I wanted mine a little earlier, so I typed one line.

Claude Code input box with the command /context-alert set percent 35 typed in, and Opus 5.5 High shown below it

The reply confirmed it.

First alert at 35%, then every 15 points after that.

Claude Code reply to /context-alert set percent 35 reading percent = 35, then first alert at 35%, then every +15 points, with the trigger set to percent

A quick /context-alert status showed me where I stood.

Output of /context-alert status showing fill now 18% (184k of 1M), asked this session none yet, next alert at 35%, and a partly blacked-out known handoff path

The session sat at 18%, which is 184k of a 1M window. Nothing had been asked yet, and the next alert was due at 35%. It even knew which handoff doc I’d been using. (Small touch. I liked it.)

About that number.

In the handoff-doc post I suggested around 20% on a 1M window, and that’s still a fine place to start. 35% is simply where I landed for this project. Pick the number that fits how you work.

The handoff-doc skill comes bundled too, so the handoff options work straight after install, even if you skipped the earlier post entirely.

.

.

.

The tap on the shoulder

Then I went back to work and forgot the alert existed.

Which, to be fair, was the idea.

A while later, the dialog appeared on its own:

The context window is now at 35% (351k of 1M tokens). Write a handoff doc before compaction?

Underneath, it named the handoff doc it already knew about. It’s polite about timing, too. The question waits until Claude finishes its reply, so it never cuts in halfway through a response.

Context Alert dialog at 35% (351k of 1M tokens) asking whether to write a handoff doc, naming the existing handoff file, with Update handoff, then compact selected, and the side panel showing 35% used and one background task running for 5 minutes

35% is my own setting. The default is 40%.

You get four choices:

  • Handoff, then compact. My usual pick. It writes or updates the handoff doc, then compacts once the doc is saved.
  • Handoff only. Handy when you’d rather /clear and start fresh from the doc.
  • Compact now. For when there’s nothing worth saving.
  • Not now. You’re mid-thought. It asks again 15 points later.

In my screenshot the first two read “Update handoff…” because the mod already knew my handoff doc. There’s also an “Other” box, and whatever you type there goes to Claude as an instruction.

Keep working past an alert and it asks again every 15 points above the last one, so 35%, then 50%, and so on. After any compaction (auto-compact included), it starts over at your first threshold.

It also sends a desktop or phone notification when the dialog opens. That’s on by default, you can turn this off if you think it’s too noisy.

.

.

.

Handoff, then compact, in one go

I picked “Update handoff, then compact” and sat back.

Since a handoff doc already existed, the handoff-doc skill had a question of its own.

  • Should it write a sequel as handoff 11,
  • Append to handoff 10,
  • Or overwrite handoff 10?

The sequel was the recommended option, and I took it.

The handoff-doc skill asking how to write this session's handoff, with Sequel as handoff 11 (Recommended) selected above Append to handoff 10 and Overwrite handoff 10, and the context panel at 35% used

When no handoff doc is known yet, Claude asks where to save one instead, and suggests a spot that matches your project’s handoff folder.

Claude then wrote handoff 11.

It covered the decisions, progress so far, the job still running in the background, what was and wasn’t verified, and the next steps. Handoff 10 stayed exactly as it was. The moment the new doc was saved, the compaction kicked off by itself.

Claude's summary after writing handoff 11 as a new file and leaving handoff 10 as it was, listing decisions, batch 1, the 0.10 job, what was and wasn't verified, next steps and open follow-ups, with a /compact message queued at the bottom

I never typed /compact myself. Not once.

.

.

.

Background work keeps going

Now for my favourite part.

That background job had been running the whole time, and it kept right on going through the alert, the handoff and the compaction.

Right after the compaction, the chat showed background commands still running.

A /compact message followed by a status line reading 3 background commands completed, 2 running

When the job finished, it reported back.

Claude checked the results and committed the work, then moved on to the next job without a word from me.

(It felt a bit like coming back from lunch to find the dishes already done.)

After compaction, 34 background commands completed and Claude carrying on by itself, checking the returned job and committing it, with the context panel showing 16% used, 158.3k of 1M

Context dropped from 35% to 16%, or 158.3k of 1M.

👉 The session carried on as if nothing had happened — with plenty of room again.

.

.

.

One tip for 1M windows

On a 1M window, the default 40% is already 400k tokens.

That’s a lot of conversation to carry. If you’d like a token cap as well, switch the trigger to “either”. The alert then fires at your percent or your token count, whichever comes first.

Order matters here.

Set the token count first, which switches the trigger to tokens. Then switch to “either”, and your percent comes back as it was (35%, in my case).

/context-alert set tokens 300000
/context-alert set trigger either

Percent only is the default. The trigger also accepts tokens on its own.

These days I don’t watch the number at all. Most days I have two or three sessions open, and I can’t keep an eye on all of their numbers. Now each one tells me when it’s time.

Install the Claude Code context alert once and hand the watching over.

And if you want the reasoning behind the habit, it’s all in the handoff-doc post.

• 14 min read • The Art of Vibe Coding

I Taught Opus 5.5 to Pick the Right Sub-Agent for Every Job

I Taught Opus 5.5 to Pick the Right Sub-Agent for Every Job

Last week I put Opus 5.5 in charge of five Haiku 5.5 workers, and together they built a game I’m genuinely proud to share.

That was round two. In round one, Haiku ran the whole show on its own and handed me something… meh.

The full story is in Can Haiku 5.5 Beat Opus 5.5? I Made It Build the Same Game Twice. The short version: Haiku 5.5 makes a poor boss and a very good worker.

And the recipe? One line in the prompt:

Use ONLY haiku 5.5 for the sub agent.

It worked beautifully. On a game.

(Hold on to those last three words. They’re about to cause trouble.)

.

.

.

Last Week’s Boss Gave Every Job to the Same Worker

A game splits neatly into five slices, one per worker, with Opus reviewing everything until it’s good. As real work goes, that’s about as tidy as it gets.

My real projects are messier. (Much messier. Ask my git history.)

In a single hour I might need a quick code search, a feature build, a security review and a written report. Four very different jobs.

Opus is overkill for the quick search. Put Haiku on the security review and it’s out of its depth. And most of the everyday building in between? That’s Sonnet’s sweet spot.

Run everything on one model and either the expensive one chews through your weekly usage on errands, or the cheap one lowers the bar where it matters.

(Hello again, meh.)

Then there’s the sneaky part.

When you spawn Claude Code’s built-in sub-agents without naming a model, they quietly use the main session’s model. The skill I’m about to show you spells out what that means under an Opus boss: “every task silently runs on Opus”.

I found out the hard way.

My weekly bar was climbing faster than the work justified, and when I finally looked, Opus was the one running my little file searches. (Picture hiring a master carpenter and sending them out for nails. All day. At master-carpenter rates.)

So who should decide which model does which job?

The boss. Once you teach it how.

This post shows how I turn my main session into a Claude Code orchestrator that picks the right model and effort for every task, then checks the work before it lands. It’s free, and you can run it today — but first, let’s meet the crew.

Two-panel whiteboard cartoon of white robots wearing name badges. The left panel, under an orange header reading One model for every job, shows a large Opus 5.5 robot in a yellow hard hat holding a clipboard and pointing at a tall blank sheet labelled Big job. Next to the sheet, a small hatless Haiku 5.5 robot holding a hammer scratches its head under three question marks, and four more identical Haiku 5.5 robots with hammers stand in a row along the bottom. The right panel, under a blue header reading This week, shows the same Opus 5.5 robot with its clipboard pointing as four arrows fan out to four groups: a Haiku 5.5 robot holding a magnifying glass, tagged find; a Haiku 5.5 robot holding a clipboard, tagged sort; three Sonnet 5.5 robots in purple hard hats laying a red brick wall with a brick and a trowel, tagged build; and an Opus 5.5 robot in a yellow hard hat holding a ticked checklist at the end of the wall, tagged review. A yellow banner across the bottom reads Same boss, right crew.

.

.

.

Every Job Has a Right-Sized Model

Remember the building site from last week’s post?

A good site runs on a foreman who plans the job and inspects the work, with skilled builders doing most of the building and a fast apprentice running the errands. Nobody hands the apprentice the blueprints, and nobody asks the foreman to sweep up.

Your Claude Code crew works the same way. Here’s how I rank the models:

ModelCost (higher = cheaper)IntelligenceTasteSpeedUse for
Haiku 5.594410narrow read-only or mechanical jobs, triage (through the gate)
Sonnet 5.56778default worker: scoped building, bug fixes, docs, tests
Opus 5.54886the boss; architecture, hard debugging, reviews, user-facing quality
Fable 5.1————opt-in only

Scores are my own judgement, used to rank the models for routing. Higher is better; for cost, higher means cheaper.

Now, the Haiku question. I know last week’s readers are already asking it. (I can practically hear the keyboards from here.)

Last week’s table gave Haiku the building too, and that worked on a game.

On a real codebase, the skill hands building to Sonnet and keeps Haiku on jobs like finding where a feature lives in the code, or cutting a long list of issues down to a shortlist.

Why so careful with the little one? Haiku is the weakest of the three at long, multi-step coding. So the skill only hands it work whose output is cheap to check — say, a list of file locations you can verify in a minute — and even then the boss spot-checks it.

Think of it as the apprentice’s first week on site. Plenty of fetching and measuring, and somebody always glances at the tape measure afterwards.

The skill calls this the Haiku gate. Every one of these has to hold:

  • Read-only or mechanical work
  • One clear objective
  • Output that’s cheap to check
  • Nothing that involves writing code, design work or reviews
  • A fixed budget and a short job

And the line that sums up the gate: “Haiku never edits repo files.” (Blunt. I love it.)

On top of the gate sits a pattern the skill calls triage-then-verify: Haiku sorts a big pile into a shortlist, and Sonnet or Opus confirms what’s on it. It works like a mailroom: someone quick sorts the post, and someone senior reads whatever actually matters.

What about Fable 5.1?

It sits behind a locked door, and runs only when you ask for it by name, or when Opus misses the same task twice and you say yes. In the skill’s words: “Opus is close to Fable on most work at a much lower price.”

(Which is a polite way of saying: keep your wallet in your pocket.)

Whiteboard-style org chart of white robots wearing name badges. At the top, a yellow-headed box reads Opus 5.5 – the boss, with the line plans · hands out work · checks · commits, and beside it stands an Opus 5.5 robot in a yellow hard hat holding a clipboard. Three arrows lead down to three cards in a row. The orange card, Haiku 5.5: quick jobs, shows a small hatless Haiku 5.5 robot running, with the bullets find files, sort a long list, summarise and read-only, cheap to check. The blue card, Sonnet 5.5: default worker, shows a Sonnet 5.5 robot in a purple hard hat and a tool belt giving a thumbs-up, with the bullets build features, fix bugs and tests & docs. The yellow card, Opus 5.5: hard calls, shows a thoughtful Opus 5.5 robot in a yellow hard hat, with the bullets architecture, tricky debugging and reviews. Off to the right, a fourth card with a dashed grey outline and no arrow reads Fable 5.1, with a padlock and the words only if you ask.

.

.

.

Meet the Orchestrate Skill

I built this skill weeks ago for my own private repos, and it’s been the boss on my projects ever since. Now it lives in CloudPlay, so anyone can use it.

The skill opens with its job description:

“You are the orchestrator. You plan, route, brief, monitor, integrate and commit. Sub-agents do the work.”

That’s the whole idea of a Claude Code orchestrator in three short sentences. (Most job ads take a full page to say less.)

With CloudPlay‘s setup, the boss loads the skill for every request except tiny ones, like a quick lookup or a one-line edit. It’s tuned for an Opus 5.5 boss and works in Claude Code only, in cloud and local sessions alike.

Here’s one run, start to finish:

  1. Preflight: checks the branch and settings
  2. Plan: writes the task list, each task labelled
  3. Route: picks model and effort per task
  4. Dispatch: sends work out in waves, five at most
  5. Brief: gives every worker a full written brief
  6. Check: verifies each result itself
  7. Merge: copies changes back, one at a time
  8. Commit: writes a handoff, pushes only the feature branch
  9. Report: shows what actually ran, and how it was checked
Whiteboard-style road map titled One run, start to finish, in a yellow banner. A winding grey road runs left to right past nine numbered pins, and an Opus 5.5 robot in a yellow hard hat walks along it at the start carrying a clipboard, toward a chequered finish flag at the far right. Above the pins sit nine stops, each with a numbered circle, an icon and a name: 1, a clipboard with three green ticks, Preflight; 2, a list with orange, blue and yellow tags, Plan; 3, a signpost with three coloured arrows, Route; 4, an open wooden gate with two hatless Haiku 5.5 robots and a Sonnet 5.5 robot in a purple hard hat and tool belt walking out, Dispatch; 5, an envelope, Brief; 6, the Opus 5.5 robot holding a magnifying glass over a ticked box, Check; 7, the Opus 5.5 robot pushing a blue and an orange puzzle piece together, Merge; 8, the Opus 5.5 robot dropping a sheet of paper into a cardboard box, Commit; and 9, a report sheet with a bar chart, Report.

Two habits jump out the first time you watch it work.

The first is the labels. Every task in the plan carries its route right at the front, like [sonnet·medium] or [opus·high], so one glance tells you who’s doing the job and how hard they’re thinking. (Like name tags at a conference, if the name tags also listed how much coffee everyone had.)

The second is the briefs. I learned this one by sending a worker a single sentence once. It came back with a tidy, confident answer to a question I never asked.

The skill is firm about why every brief gets written out in full:

“Never send a one-liner: the worker has none of your context.”

Honestly, that’s advice I should follow with humans too.

Enough theory. Let me show you a real run.

.

.

.

A Real Run, Caught Mid-Way

This task list comes from one of my own projects, captured in the middle of the implementation.

(Mid-run screenshots are the honest ones. Nobody has tidied up for the camera yet.)

A dark Claude Code task list caught part-way through a run, with 20 earlier steps collapsed at the top. Every visible row starts with a model and effort label in square brackets. From the top: a sonnet·medium row compiling final report inputs (read-only); a sonnet·high tooling pass that fixes a race in a build script and adds smoke checks; three sonnet·medium audit rows, each comparing a slice of a changelog against the built plugin (read-only); an opus·medium row building a batch of missing features on the live test site; an opus·high row building backup notes, upload and restore features on the live site; an opus·high security and regression review of the first build (read-only, alongside the second build); an opus·high security review of the second build (read-only, after it); an opus·medium row fixing the first review's findings on the live site; an opus·high row fixing the backup findings, shown in progress with 1 running task beneath it; and a final sonnet·medium row compiling the final report's task table (read-only).

The 20 steps collapsed at the top were the main build. What you see is the later stretch, where the boss checks the build against what it promised and fills the gaps.

Look at the quiet jobs first. Compiling the report inputs and three audits all ran on Sonnet at medium effort, each one marked read-only. A tricky tooling fix went to Sonnet too, at high effort.

The audits turned up missing features, so the boss added two gap-filling builds to the list and sent both to Opus, one at medium effort and the harder one at high.

Wait. Isn’t Sonnet the default builder?

It is, for scoped work.

My read is that these builds were a different animal: they touched a live test site and many features at once. The skill sends that kind of sprawling, edge-case-heavy job to Opus. (Sonnet is a fine builder. For a renovation with the family still living in the house, though, you call in your most senior hands.)

Now look at what happened after each build.

Each one got its own Opus security review at high effort. The first review ran alongside the next build, since a review only reads. When the reviews came back with findings, the boss added a fix task for each, and those went to Opus too.

Here’s the thing that makes me trust the result: the task list keeps growing as the checks come back. (A to-do list that grows by itself would normally fill me with dread. Here, it’s the best sign in the room.)

One more thing caught my eye: those three audits were read-only, so why not Haiku? My read is that comparing a changelog against a built plugin takes judgement, and a judgement call takes real effort to check, which fails the Haiku gate.

Which brings us to the second dial on every task: effort.

The model decides who does the job. Effort decides how long that worker thinks before it acts. The skill’s rules:

  • Start at medium, for all three models
  • Quick, single-lookup Haiku jobs drop to low
  • Raise to high for reviews, architecture and tricky debugging
  • The two levels above high “are not defaults anywhere”

The boss turns effort up only for a reason. That tooling fix was a timing bug in a build script (two steps racing each other to the finish), which is exactly the kind of tricky bug that earns Sonnet a step up to high.

Whiteboard-style control panel with two big knobs, each with an arrow running down to a task card. The left knob, under an orange header reading WHO (model), has notches for Haiku, Sonnet and Opus, with its pointer on Sonnet, plus a greyed-out fourth notch, Fable, with a small padlock. The right knob, under a blue header reading HOW HARD (effort), has notches for low, medium and high, with its pointer on medium, plus greyed-out notches for xhigh and max. The orange and blue arrows meet on a note card reading sonnet·medium in square brackets, then Add a settings field. On the left, an Opus 5.5 robot in a yellow hard hat with a clipboard points at the panel while a small hatless Haiku 5.5 robot cheers below it; on the right, a Sonnet 5.5 robot in a purple hard hat and a tool belt with a wrench points at the panel too. A yellow footer reads Start at medium. Turn it up for a reason.

.

.

.

Five Workers, One Clean Branch

So far we’ve got the right worker and the right effort for each job.

Now for the rails. Five workers changing one project at once sounds like a recipe for shenanigans. (If you’ve ever shared a spreadsheet with four colleagues on deadline day, you know exactly how that ends.)

The skill’s answer is separate desks.

Up to five workers run at once, and the ones that write at the same time each get their own desk: a separate copy of the project, called a git worktree. (If worktrees are new to you, I walked through them in How I Vibe Code With 3 AI Agents Using Git Worktrees (Without Breaking Anything).)

When a worker finishes, the boss copies its changes back to the main desk, one worker at a time, and checks each one there. It keeps an undo for every copy, so a bad batch can be rolled straight back.

If two workers touched the same lines, the boss settles it itself.

It’s the one holding the decisions, after all.

Then come the branch rules, and they’re strict. (Good. Strict is exactly what I want here.)

A run never touches your main branch. It works on a feature branch and pushes only that branch. Workers never commit either.

Only the boss commits, and every commit carries a handoff doc: a save point that lets the next session pick up exactly where this one stopped. The boss writes it with the skill from Stop Losing Work When You Compact Claude Code (The Handoff-Doc Skill), and the hooks that enforce it come up again in the CloudPlay section.

Whiteboard-style office scene. In the centre, an Opus 5.5 robot in a yellow hard hat sits at a big desk with a laptop and a clipboard; the desk's sign reads Main desk: feature branch. A blue arrow rises from it to a cloud reading push: feature branch only. In the top-left corner, a chain-link fence with a padlock surrounds an empty space under an orange sign reading main, with a yellow sign below reading Nobody works here. Along the bottom sit three smaller desks, each labelled Worker desk, each with a Sonnet 5.5 robot in a purple hard hat and a tool belt working at a laptop beside a sign reading No commits. A blue arrow runs from each worker desk back up to the main desk, each with a small circular undo icon, and the left arrow is labelled changes copied back, one at a time. A bookshelf, a filing cabinet and a window fill the top right.

.

.

.

When a Worker Misses the Bar

Here’s my favourite line in the whole skill. If I could frame one sentence and hang it over my desk, it would be this one:

A worker’s “done” is a claim. Verify it yourself before marking a task completed.

I’ve had a worker tell me everything passed when the checks had never actually run. Since then, I trust the boss’s check more than the worker’s word.

So the boss runs the check itself before it ticks a task off. On top of that, every Haiku result gets a spot-check.

And when the work comes back wrong?

The skill has a ladder, and the right rung depends on what went wrong:

  • Stopped part-way: resume the same worker where it left off
  • Wrong or off-scope (the brief was the problem): re-brief a fresh worker
  • The model fell short: turn the effort up one step, else move up one model
  • Haiku over budget or erroring: straight to Sonnet
  • Two delegated retries used up: the boss does the job itself
  • Opus missed twice: the boss asks you about Fable

Fable only shows up at the very top, behind a door you have to open yourself.

When the run ends, the report shows exactly what ran, including any climb up the ladder. Anything that failed or stayed unverified goes in it too, stated up front. In the skill’s words: “say so plainly, never bury it.” (Bad news delivered early is a gift. The skill seems to know that.)

And for fans of my hands-off prompts (“build the game without asking me any questions at all”), there’s a no-ask mode: the boss makes the calls itself and lists every one in the report, with Fable kept out and the hard rules still on.

(Guilty. I’m the biggest fan.)

Whiteboard-style wooden ladder climbing toward a door, with its rungs grouped into three coloured bands. The bottom yellow band holds a small hatless Haiku 5.5 robot, with a side label reading Haiku: low → medium → high, over budget? → Sonnet. The middle blue band holds a Sonnet 5.5 robot in a purple hard hat and a tool belt giving a thumbs-up, labelled Sonnet: medium → high. The top orange band holds an Opus 5.5 robot in a yellow hard hat with a clipboard, labelled Opus: medium → high → xhigh. Beside the ladder, a big orange upward arrow reads 1. Turn up the effort, 2. Then move up a model. Two pinned sticky notes read Stopped part-way? Resume. and Bad brief? Re-brief., and a chalkboard at the foot reads Max 2 retries, then the boss does it. At the top of the ladder, a wooden door carries a padlock labelled Fable 5.1, with a hanging sign reading Opus missed twice + you approve.

.

.

.

Get It Running With CloudPlay

Ready to try it yourself? Good, because this is the easy bit.

CloudPlay is built for Claude Code on the web, the cloud version of Claude Code at claude.ai/code. I introduced it in Can Sonnet 5.5 Really Build a Full Game From One Prompt? I Tested It., where one prompt before bed turned into a playable game by morning.

A cloud session normally starts empty, like a rented flat with nothing but the light bulbs.

Pick CloudPlay as the repo and every session opens with my tools already in place: a self-hosted Firecrawl for web search and scraping (no API keys needed), a browser so Claude can check its own work, and the handoff hooks from I Burned 40% of My Max 20x Week Overnight. Here’s How I Fixed My Claude Code Cloud Setup. The orchestrate skill is the newest addition, so every cloud session now comes with a boss that knows how to route its crew.

Here’s how to get going:

  1. Fork or clone CloudPlay and build your project on it. The skill and its settings are already in place.
  2. Open the repo in Claude Code on the web and pick a cloud environment with network access. Mine runs on Full Access, since the first start pulls in Firecrawl and the browser.
  3. Give the first session a minute or two to set itself up.
  4. Hand the boss a big job and close the laptop.

Step 4 is the best part. (It’s also the hardest, if you’re the type who keeps peeking at the progress.)

If you want a Claude Code orchestrator in your own cloud projects this week, that’s the quickest way to get one.

Already have a project? The README’s Orchestration (optional) section shows how to add the pieces to your own repo. One tip from it is worth knowing: commit the worktree setting. Cloud sessions only read settings you’ve committed, and without this one your writers take turns, one at a time. (Five workers in a single-file queue. Exactly as slow as it sounds.)

Like the rest of CloudPlay, it’s MIT-licensed.

Whiteboard-style stack of four layers under a hand-lettered CloudPlay title. The bottom grey layer reads Claude Code on the web. The blue layer above it reads Start-up hook and holds two boxes, Firecrawl: search & scrape and Browser for testing. The orange layer above that reads Handoff hooks: a save point every commit. The top yellow layer reads Orchestrate skill, with a red-and-white NEW starburst and a star at each end, and an Opus 5.5 robot in a yellow hard hat stands on it holding a clipboard. To the left, a laptop whose screen reads Open a session. Set up for you. sends a green arrow into the Start-up hook layer.

.

.

.

Your Turn: Give Your Boss a Proper Crew

Last week, Haiku found its job: working under a strong boss.

This week, the boss learned to give every worker a job that fits. The whole building site, finally staffed properly.

I run this setup on my own projects, but I have no usage numbers to show for it yet. (Very scientific, I know.) So try it on your own work and keep one eye on your weekly bar.

Here’s your challenge: give a CloudPlay cloud session a real multi-step request, then look at the labels in the task list.

Would you have routed any of those tasks differently? That’s the part I most want to hear about. (Arguing with the boss is half the fun.)

👉 Start your next project from CloudPlay (or copy the skill in) and reply with the first plan your boss writes.

Haiku finally has a job. Now so does everyone else on the crew.

• 18 min read • The Art of Vibe Coding

Can Haiku 5.5 Beat Opus 5.5?

Can Haiku 5.5 Beat Opus 5.5? I Made It Build the Same Game Twice

Last week Anthropic launched Haiku 5.5, its cheapest small model yet. Within days, my YouTube feed had moved on to a much bigger question: can Haiku 5.5 beat Opus?

Haiku, the little one — the model most of us have used for one very silly job (more on that later).

Taking on Opus?

Anthropic, for its part, calls it “the cheapest, fastest, and most capable small model we’ve ever released”. The basics:

  • Launched: October 7, 2026
  • Price: $0.10 per million input tokens and $0.50 per million output tokens (for prompts up to 100k tokens)

That’s a bold line. YouTube, meanwhile, had its eye on a different prize.

Two YouTube video cards, one above the other. The top one, a thumbnail of an army of small orange robots labelled Haiku 5.5 Army facing one big orange robot labelled Opus 5.5, is titled Can an Army of Claude Haiku 5.5 Subagents Beat Opus 5.5? by Dubibubi. The bottom one, a black thumbnail reading Haiku 5.5 Better Than Opus 5.5? with hand-drawn notes like 40 times cheaper, is titled Haiku 5.5 Is Faster, Cheaper, and Better Than Opus 5.5? What Is Going On? by Marfil Draws and Local Explained

Those two are Can an Army of Claude Haiku 5.5 Subagents Beat Opus 5.5? by Dubibubi, and Haiku 5.5 Is Faster, Cheaper, and Better Than Opus 5.5? What Is Going On?, a collab between Marfil Draws and Local Explained.

Both titles end in a question mark, which I appreciate. The second thumbnail asks it most bluntly: “Haiku 5.5 Better Than Opus 5.5?”

Is it tho?

Here’s why the question matters. Haiku costs a sliver of what Opus costs. If the cheap model can do the job, everyone’s usage stretches a whole lot further.

If you’re on a Pro or Max plan, you know exactly which number I mean. The weekly bar is the number everyone watches, like a fuel gauge on a long drive with no petrol station in sight. A model that could do Opus-level work at Haiku prices would make that bar last a lot longer.

So I made it build the same game twice. (Of course I did.)

I reused the family of prompts from my post two weeks ago, Can Sonnet 5.5 Really Build a Full Game From One Prompt? I Tested It., where one prompt and about five hours got me a playable kart racer. The cloud setup stayed the same as well: one prompt from me, then silence until the report came back.

The two rounds:

  • Round one: Haiku 5.5 as the boss, running five Haiku 5.5 workers
  • Round two: Opus 5.5 as the boss, running the same five Haiku workers

One of them genuinely surprised me.

.

.

.

Round One: Haiku 5.5 Runs the Whole Show

Round one first. I handed the whole job to Haiku, boss and crew alike, with this prompt:

I need you to launch five haiku 5.5 sub-agents and help me build a triple A quality game that is a clone of "_____". What I want you to do is I want you to launch these sub-agents, build the game without asking me any questions at all, and use ThreeJS to build the gameMake sure to create a new branch for this game called it "games/__-haikumax"Since we will be running five haiku 5.5 sub agents at the same time, you MUST setup worktrees (here's how: https://code.claude.com/docs/en/worktrees.md) for each sub agent to work with so that they can work independently on different aspects of the game development.You will coordinate the work of the five sub-agents, ensuring that they are all aligned and working towards the same goal. You will also need to manage the integration of their work, ensuring that all components of the game are compatible and function together seamlessly.You can use "playwright-cli" to verify your own work.You may use "firecrawl" if you need to do any research about the game.The game should be frontend only for now. All the persistent data will be stored in local storage.Make sure the game is playable with mobile phone as well.Please create tasks for this first, and then assign sub agent to each task. You may run up to 5 sub agents at a time.Publish the game to Cloud Artifact as you build, so that I can see your work.And once you're done, report back to me.
Claude Code on the web showing the full Haiku-only prompt in the chat, with the cloned game's name and most of the branch name blacked out, and Haiku 5.5 at Max effort selected in the model picker at the bottom right

If it looks familiar, that’s because it’s the revised prompt from last week’s post, I Burned 40% of My Max 20x Week Overnight. Here’s How I Fixed My Claude Code Cloud Setup., which itself grew out of the Sonnet post’s prompt. This time I added two things:

  • A new branch for the game, so the build lives on its own line of work
  • A separate copy of the project for every worker, so five of them can build at the same time without stepping on each other’s toes

(I walked through that second idea in How I Vibe Code With 3 AI Agents Using Git Worktrees (Without Breaking Anything).)

You’ll notice a black box where the game’s name should be. The target was a classic humans-vs-orcs real-time strategy game, and I’d rather avoid love letters from the publisher’s lawyers.

If you know, you know.

So, did it work?

Well…

Here’s the result:

Emberwood Wars trailer: an opening title card reading Emberwood Wars, Real-Time Strategy over a 3D village on bright green grass, then four chapter cards in turn, I Gather with villagers working near blue-roofed houses, II Forge with the town growing beside two blue lakes, III Command with soldiers gathering by a red-roofed enemy base, and IV Conquer with an army marching on the red town hall, ending on the title card Emberwood Wars, Forge. Command. Conquer.

Play Emberwood Wars in your browser.

This looks… meh.

Sorry, Haiku.

The trailer is nicely cut, I’ll give it that. It has proper title cards and four chapters, and it ends on a little army marching on an enemy town hall. Very dramatic. Now look past the trailer at the game underneath.

Blocky 3D houses on a bright green field. The original game has a flat, pixel-art charm, and this has none of it. (It looks like someone described the original to Haiku over a bad phone line.) Put it next to Sonnet 5.5’s Kart Blitz and it sits clearly lower.

Beating Opus? Nowhere near.

What it does have is speed. This is probably the fastest game I’ve ever completed.

Claude Code session stats for the Haiku-only build: cost $11.37, API time 3h 24m, and Haiku at 100% of the session
  • Main session: Haiku 5.5 at Max effort
  • Workers: 5× Haiku 5.5
  • Cost: $11.37
  • Run time: 3h 24m

Under four hours, for about $11. Pocket change, as game builds go.

Yes, it’s fast and cheap. But if the quality isn’t there, what’s the point?

Here’s my read. Haiku 5.5 is a decent model that needs a lot of hand-holding. What it lacks is the relentlessness that Sonnet and Opus bring — that stubborn drive to keep working until the result is actually good. Left in charge, Haiku settled for meh.

The last time I handed an older Haiku a real coding task, I spent longer cleaning up after it than the job would have taken Sonnet.

In fairness, the prompt asked a lot: run five workers and build a full game without asking me a single question. Haiku delivered something playable in under four hours and called it done.

And that got me thinking…

.

.

.

Round Two: Opus 5.5 Takes Command

What if Opus 5.5 ran the show, and the five Haiku 5.5 workers did the building?

Last week I described the main agent as a supervisor paid by the hour to check on the work. This time I kept the expensive supervisor and made the whole crew cheap. (Every project manager’s daydream, really.)

My thinking went like this. What round one lacked was somebody in the session willing to push back on “meh”. That kind of judgement call is where Opus shines. So what happens if I swap only the boss and keep the cheap crew?

I set Opus 5.5 to xHigh effort (the picker calls it “Extra”) and sent this:

I need you to launch five haiku 5.5 sub-agents and help me build a triple A quality game that is a clone of "____". What I want you to do is I want you to launch these sub-agents, build the game without asking me any questions at all, and use ThreeJS to build the game.Make it pixel based (not 3D), similar to the original game.Make sure to create a new branch for this game called it "games/___-opus-haiku"Since we will be running five haiku 5.5 sub agents at the same time, you MUST setup worktrees (here's how: https://code.claude.com/docs/en/worktrees.md) for each sub agent to work with so that they can work independently on different aspects of the game development.You will coordinate the work of the five sub-agents, ensuring that they are all aligned and working towards the same goal. You will also need to manage the integration of their work, ensuring that all components of the game are compatible and function together seamlessly.You can use "playwright-cli" to verify your own work.You may use "firecrawl" if you need to do any research about the game.The game should be frontend only for now. All the persistent data will be stored in local storage.Make sure the game is playable with mobile phone as well.Please create tasks for this first, and then assign sub agent to each task. You may run up to 5 sub agents at a time. Use ONLY haiku 5.5 for the sub agent.Publish the game to Cloud Artifact as you build, so that I can see your work.And once you're done, report back to me.
Claude Code on the web showing the Opus-led prompt, including the lines Make it pixel based (not 3D), similar to the original game and Use ONLY haiku 5.5 for the sub agent, with the game's name and part of the branch name blacked out, and Opus 5.5 at Extra effort selected in the model picker

What changed:

  • The boss: the main session switched to Opus 5.5 at xHigh
  • “Make it pixel based (not 3D), similar to the original game.” The first run gave me a 3D game, and the original is flat and pixel-based
  • A new branch name
  • “Use ONLY haiku 5.5 for the sub agent.” This keeps every single worker on Haiku

Worth knowing: the prompts differ slightly, so this is a variation on the experiment. (A lab coat would be wasted on me.)

Here’s the result:

Tides of Conquest trailer: a black title card reading Two Races, then pixel-art scenes with gold captions, Build Your Kingdom over a town of blue-roofed buildings, Command Vast Armies as human and orc troops clash on grass, Wield Ancient Magic as a glowing spell sweeps across the battlefield, Rule the Seas with warships trading fire on blue water, and Burn Their Cities as a town catches fire, ending on a gold Tides of Conquest logo with Play Free in Your Browser and Humans, Orcs, Campaign, Skirmish, Naval War

Play Tides of Conquest in your browser.

Pretty cool, right?

Now that’s more like it.

This one has the flat pixel-art look I asked for, with two races at war and ships out on the water. Put the two trailers side by side and the gap is obvious within seconds. This one looks like the game I had in mind when I typed the prompt.

There was a catch, of course. This time it ran way, way longer than the Haiku-only build.

Claude Code session stats for the Opus-led build: cost $293.64, API time 19h 28m, with both Haiku at 68% and Opus at 32% listed on the same session
  • Main session: Opus 5.5 at xHigh effort
  • Workers: 5× Haiku 5.5
  • Cost: $293.64
  • Run time: 19h 28m

Freaking 19 hours… and $293.64.

I checked in on it a few times that day. Every time, it was still going, polishing something I hadn’t asked for.

Both models show up on the one bill. (Before you wince at that number, it’s Claude Code’s estimate at API prices. I ran this on my Max 20x plan and paid none of it. More on that in the cost section.)

Yes, it cost way more. But the quality? Day and night.

With Opus as the boss, the build kept going until the game was playable and as close to the original as it could get.

Let me show you what I mean.

.

.

.

What Opus Got Out of the Same Cheap Workers

Here’s the part I keep coming back to. Same five workers and the same kind of prompt, yet a very different game.

The difference was the boss. Here’s what Opus did, in the order I noticed it. (There are six. Grab a coffee.)

1. Art Before the Game

Opus understood that a game needs its pieces drawn before anyone can play with them. So before touching the game itself, it had the art worker draw the units and buildings, pose by pose, on preview sheets.

It built the chess pieces before setting up the board.

Tides of Conquest art preview page showing rows of pixel-art units for both sides, workers, foot soldiers and archers among them, each drawn facing several directions on a dark green background
Tides of Conquest building preview sheet with two rows, human buildings with blue slate roofs on top and orc buildings with thatched roofs below, each shown at three construction stages from bare foundation to wooden frame before the finished town hall

Then it put those pieces on the map.

In-game Tides of Conquest scene on a grass map: a rocky gold mine with a timber doorway, a stone town hall with a blue roof and bell tower, a single worker in a straw hat walking out front, boulders at the lower left, a minimap in the top corner, and resource counters for gold, lumber and food along the top

By the time the gameplay came together, the pieces were already waiting.

That order matters more than it sounds. With the art drawn first, every worker building the game was aiming at the same picture. Think of it as handing five painters the same reference photo before anyone opens a tin of paint.

2. Homework on the Original

At one point, Opus went off and downloaded screenshots of the original game so it could study the art style.

Claude Code transcript where the main agent says it will pull a few original screenshots itself for style reference, followed by small pixelated thumbnails of downloaded battle screenshots and a note that it now has one usable in-game shot of a winter battle to compare the art against

Haiku alone never did this.

It’s a small moment, and it told me a lot. Opus wanted to know what “similar to the original” actually looked like, so the art worker had something real to compare against.

Then there was how much game there was.

3. Two Game Modes

Here’s the title screen.

Tides of Conquest title screen in pixel art: a moonlit sea between a white human castle on the left cliff and a dark orc fortress on the right, a ship on the water, the subtitle Humans Against Orcs, and stone-style menu buttons for New Skirmish, Campaign, Load Game, Options and How to Play

That’s a lot of game from a prompt that never mentioned game modes at all. (I asked for a clone. Opus apparently read that as “the whole box, please.”)

Skirmish mode lets you pick a side and a colour, add up to three computer opponents, set the difficulty, and choose a battlefield.

Skirmish setup screen with the Humans race card selected next to Orcs, eight colour swatches, one orc opponent set to Normal difficulty with an Add opponent button, and battlefield thumbnails starting with a random map

The campaign is where it gets a little spooky, because it mimics the original. There’s a map with a route through the missions, briefings with objectives, and a proper defeat screen when things go wrong. Win a mission and the next one unlocks, with your progress saved in the browser.

Campaign screen on the orc side with a parchment map and a red dashed route, above a list of four missions where the first is available and the rest, including mission three, Grim Tide, are locked
Mission briefing for Grim Tide, mission 3 of 4 for the orcs, with a pixel-art orc portrait in front of a brick wall decorated with skulls, and two objectives: build 2 oil platforms and sink the human fleet
Defeat screen reading Grim Tide is lost, winner Humans, with a stats table of units trained, lost and killed, buildings built, gold and lumber, and buttons for Retry, Campaign and Main menu

Yes, the graphics look different from the original, and that’s expected. The original took a team of designers and developers years to make. Nobody should expect one AI model to match it in a matter of hours. At least for now.

The gameplay, though? Very close.

And then Opus headed out to sea.

4. Ships, Then Better Ships

There are naval units and sea battles too.

Naval combat in Tides of Conquest: several pixel-art ships on open blue water below a grassy coastline, two round oil spots in the sea, a minimap in the top corner, and an oil counter in the resource bar

Then came a detail I never asked for.

Opus looked at two of the finished ships, judged them not good enough, and had them redrawn. Entirely on its own.

This is the moment that got me. Those ships were already finished. Opus simply decided they could look better.

Before-and-after sprite sheet of two warships on blue water: the first, a round spiked vessel, redrawn as a long armoured ship with rows of oars, and the second, a squat domed vessel, redrawn in lighter, cleaner colours

Turns out that pickiness ran all the way through the build.

5. Catching Its Own Mistakes

Opus kept the art worker going through review after review. On round 22 — yes, twenty-two — the review turned up real problems: some icons were completely blank, and some upgrade icons looked too alike to tell apart.

They got fixed.

Opus also decided what to leave alone. One flagged item stayed exactly as it was, as a deliberate choice for the phone layout.

The main agent's summary of the art worker's review round 22, listing the defects it found, including four blank icons and level-two upgrade icons that looked almost the same as level one, followed by the main agent keeping one flagged item as a deliberate phone-layout choice and a before-and-after sheet of spell, research and upgrade icons, the blank ones now filled in

I never asked for any of this.

Twenty-two rounds of review, on the art alone. That’s the patience Opus brought to the job.

6. Twenty Versions

Opus published version after version, and only called the game finished at version 20.

The main agent's final report: Tides of Conquest finished and published as version 20, followed by a list of what's in the game, from skirmish and campaign to naval play and phone support, and how it was built, with five Haiku workers, 93 tasks and every merge checked in a browser, with the original game's name and part of the branch name blacked out

From its final report:

  • 93 tasks in total
  • Five Haiku workers, each in its own worktree: art; maps and pathfinding; game rules; computer opponent and sound; interface
  • A strict bar for every change: it counted only if every test passed and the computer opponent still won all 8 missions on hard
  • Each merge checked in a real browser
  • 11 named maps, plus random maps
  • 8 campaign missions, 4 per side
  • Works on a phone, upright and sideways

If I had to sum up this run in one word, I’d borrow the word I used back in round one for what Haiku was missing.

Relentless.

That’s the trait the Haiku-only run lacked. And it turns out it lives in the boss.

.

.

.

Haiku Finally Has a Job

So that’s the evidence. Now for what it means, and the news is good for the smallest model in the family.

For the longest time, Haiku models were close to useless for real work. Most people used them for exactly one trick: sending a quick “hi” to start the five-hour usage clock early.

I’ll admit I’ve done it too: a quick “hi” to Haiku first thing in the morning, just to get the five-hour clock ticking.

Three-panel meme in a cosy kitchen: a small boxy robot labelled Haiku 4.5 asks What is my purpose?, a cheerful scientist in glasses replies You say hi to subscribers to start their quota, and the robot clutches its head saying Oh my god

Poor thing. Good news, though. With Haiku 5.5, the little model finally has a real job: working under a strong boss.

It’s cheaper than before, too. Anthropic puts it at about 75% cheaper than Haiku 4.5 on average. And it’s genuinely useful now.

Its place is under a strong orchestrator, doing two things well:

  • Exploring a codebase to find where things live
  • Implementing a clearly scoped task

In everyday terms, that’s the legwork of a coding session. Searching through a project to find where a feature lives. Making a change that someone has already described clearly. Haiku is fast and cheap at both, and when it misses, a good boss catches it.

The high-level decisions belong to Sonnet or Opus. So does the most important call of all: “Is this good enough yet?”

Picture a building site. Give a skilled foreman a fast, cheap crew, and you get a castle. Put one of the crew in charge of the site, and you get a lopsided shed.

Two-panel whiteboard drawing. On the left, under Haiku as the boss, a confused Haiku 5.5 robot in a hard hat scratches its head while five small worker robots wander around a lopsided wooden shed with loose bricks on the ground. On the right, under Opus as the boss, an Opus 5.5 robot foreman with a clipboard points the way while the same five workers carry bricks, paint and measure beside a finished stone castle with blue turrets. Banner along the bottom: Same crew. Different boss.

Here’s the funny part. After those two runs, I went back to Anthropic’s launch post, and it reads like a description of what I’d just watched.

Anthropic says Haiku 5.5 “pairs well with Opus 5.5 and Sonnet 5.5 as a subagent on coding work.”

It also says “Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding tasks.”

Read those two lines together and, well, there it is. That’s the exact split from my runs. Haiku does the hands-on work under a bigger model, and the bigger model keeps the complex decisions.

One benchmark from that post backs it up:

BenchmarkHaiku 5.5Sonnet 5.5
Terminal-Bench 4.039.2%70.6%

My two runs and Anthropic’s own wording tell the same story.

.

.

.

Did It Save Anything? The Honest Cost Comparison

But…

I can hear the objection from here. You could argue this combination doesn’t look like much of a saving. The Opus-led build cost $293.64. The Haiku-only build cost $11.37.

Fair point. A big, $293.64-shaped point. So let’s bring in a third build.

Metro Bus Simulator was one of the five games from last week’s post, built entirely on Sonnet 5.5 at Max effort. It’s a different game, so it only works as a rough reference. Still, it’s the closest thing I have to a “what would Sonnet alone have cost?” number.

Claude Code session stats for the Sonnet-only build: cost $351.55, API time 17h 9m, and Sonnet at 100% of the session

Here are all three side by side:

BuildMain sessionSub-agentsCostRun time
Emberwood Wars (RTS clone)Haiku 5.5 (Max)5× Haiku 5.5$11.373h 24m
Tides of Conquest (same RTS clone, pixel prompt)Opus 5.5 (xHigh)5× Haiku 5.5$293.6419h 28m
Metro Bus Simulator (different game)Sonnet 5.5 (Max)Sonnet 5.5$351.5517h 9m
Whiteboard drawing of three builds as cards. Haiku only shows a robot foreman in an orange hard hat with five workers beside a rickety shed, tagged $11.37 and 3h 24m. Opus + Haiku shows a foreman with a clipboard and five workers hauling stone for a castle tower, tagged $293.64 and 19h 28m. Sonnet only shows a crew in purple hard hats with tools in front of a city bus, tagged $351.55 and 17h 9m. A sticky note in the corner reads API-price estimates, and the banner says Three builds. Three bills.

What the numbers say about the Opus + Haiku build:

  • About 16% cheaper than the Sonnet-only build (a different game, so treat it as a rough reference)
  • Roughly two hours longer than the Sonnet-only build (19h 28m vs 17h 9m)
  • 26× the cost, give or take, of the Haiku-only build

Put plainly, the boss-and-workers setup came in under a full Sonnet build and ran a little longer. The jump from the Haiku-only run is the price of going from meh to day-and-night.

Play Metro Bus Simulator if you’re curious what the third bill bought.

One more thing about those dollar figures, because they do look scary.

They’re Claude Code’s estimates of what each run would cost at API prices. I ran all three in Claude Code on the web, on my Max 20x plan, and paid none of it. My monthly bill stayed exactly the same.

So read the numbers as a gauge. They show roughly how much of the plan’s usage each run burned.

If you’re on a subscription too, that’s the useful way to read any cost panel in Claude Code. A bigger number means a bigger bite out of your week.

.

.

.

The Verdict and the Recipe

So, back to the question from the top: can Haiku 5.5 beat Opus 5.5?

Here’s my honest answer. Haiku 5.5 makes a poor boss and a very good worker. On its own, it gave me a cheap, forgettable game, finished fast. Under Opus, it helped build a game I’m proud to share.

The little robot just needed a strong manager.

Here’s the recipe.

Pick Opus 5.5 as the boss. Then add one line to your prompt:

Use ONLY haiku 5.5 for the sub agent.

That single line keeps every worker on Haiku. Then split the jobs like this:

JobWho does it
Planning the work, splitting it into tasksOpus 5.5 (the boss)
Deciding when the result is good enoughOpus 5.5
Exploring a codebase, finding where things liveHaiku 5.5
Implementing a clearly scoped taskHaiku 5.5
Merging and checking the work in a browserOpus 5.5

The steps:

  1. Pick Opus 5.5 as the main session
  2. Add the Haiku line to your prompt
  3. Give each worker its own worktree, so all five can build at once
  4. Let the boss review the work and send it back until it’s good

Step 4 is where the real value sits. That review loop is the relentlessness Haiku lacks on its own, and it’s the part you’re really paying Opus for.

My guess is that this works best when the job splits cleanly into separate pieces, the way a game splits into art, maps, rules, the computer opponent and the interface. Each worker gets one piece, and the boss holds the whole picture.

Fair warning: this is two runs and a lot of vibes. (Very scientific, I know.) Everything here comes from what I saw on screen, so try it on your own work and see whether it holds up.

Start by playing both games side by side. They’re Claude Artifacts, so they run right in your browser:

👉 Then run the recipe on your next project, and reply with what Haiku 5.5 built for you. I’d love to see what your own crew comes up with once it has a proper boss.

• 13 min read • The Art of Vibe Coding

I Burned 40% of My Max 20x Week Overnight. Here’s How I Fixed My Claude Code Cloud Setup.

I Burned 40% of My Max 20x Week Overnight. Here's How I Fixed My Claude Code Cloud Setup.

Last week I published Can Sonnet 5.5 Really Build a Full Game From One Prompt? I Tested It. — one prompt, about five hours, a playable kart racer waiting in the morning. Zero messages from me while it ran.

It worked so well that I kept going.

I ran the same style of prompt on five more games:

  • Nachtfrost — zombie first-person shooter
  • Meridian — flight simulator
  • Metropolis 2000 — city builder
  • Stormwing — jet fighter
  • Metro Bus Simulator — bus driving simulator
Looping gameplay collage of five games built by Sonnet 5.5 in a 3-plus-2 grid: Nachtfrost, a zombie first-person shooter seen down the barrel of a gun; Meridian, an airliner flying into a golden sunset; Metropolis 2000, a blocky city builder with a population counter; Stormwing, a jet fighter dogfight over a coastline; and Metro Bus Simulator, a city bus pulling into a stop with a speedometer and route list on screen

Playable links for all five are at the end of this post.

I’ve been busy… well, actually it was Sonnet 5.5 and Anthropic’s cloud that were busy. My job was to submit the prompt and wait for the results. Some games took a few hours. Some took days. While they built in the background, I was focusing on other work.

Then came the morning I’d rather forget.

When I went to sleep, my weekly bar was sitting at about 38%. Three cloud runs were building in the background.

The first thing I did that morning was grab my phone to see which games had finished. None had. What I saw instead was my weekly bar — sitting at around 80%. More than 40% of my weekly Claude Code usage, eaten overnight.

Oh sh*t…

The remaining 20% was gone before lunch. Two days into the week, with four still to go before my scheduled reset, the whole thing was empty. (I’m fairly sure everyone on a Pro or Max plan has had this exact morning at least once.)

I used the free reset Anthropic handed out with the Opus 5.5 launch to get my week back. Then I changed four things so it wouldn’t happen again.

This post walks through all four. Fair warning — I have no clean before-and-after numbers. These are the changes I made after the burn.

.

.

.

What Actually Ate the Week

The three overnight runs each had different setups — mixed combinations of settings that, looking back, I hadn’t thought through carefully enough. Two things stood out.

First, none of them had an auto-compact window set.

Sonnet 5.5 runs with a 1M context window, and every turn sends the entire conversation back to the model. In my runs, cloud sessions seemed to pile up context faster than the same prompt on my own machine. Going past 200k was easy, and without a cap, a session could be hauling 400-500k of context on every single turn.

Think of it like a backpack that gets heavier with every step.

You carry the whole thing on every trip — and each trip costs based on the weight. With several sub-agents working at once, each carrying its own growing backpack, the total adds up fast.

Animated whiteboard showing how context grows each turn: a robot labeled Claude carries a 50k bundle toward the model on Turn 1, with the bundle growing to 200k, 400k, and 500k on successive turns while the weekly usage meter drains faster each time, ending with five sub-agents each hauling their own large bundle and the caption Every turn carries the whole conversation

Second, at least one of the runs was building with a single sub-agent at a time — and dragging on for days while the context kept growing. Combined with the missing auto-compact cap, that slow run was part of what drained the week.

So, how do we solve this?

.

.

.

Fix #1: Make /autocompact the First Thing You Type

The first thing I do to keep Claude Code usage in check in a cloud session is one command, typed before my prompt.

After picking the cloud environment and the repo, before I send anything else, I type:

/autocompact 400k
Claude Code on the web composer showing Full Access, cloudplay, and main branch chips above the input box, with /autocompact 400k typed in and Sonnet 5.5 at Max effort on the right

That’s how I start every cloud session now.

The command caps how big the conversation can grow before Claude Code compacts it automatically — in this case, 400k tokens. The setting is saved per model, and the confirmation reply names the model it applied to: “Auto-compact window for Sonnet 5.5 set to 400k tokens.”

Claude Code session titled Autocompact 400k showing the Full Access cloudplay badge, the /autocompact 400k command bubble, and the reply Auto-compact window for Sonnet 5.5 set to 400k tokens

To verify it took, open the Context window popover — the ring next to “Sonnet 5.5 · Max” — and check the denominator. It should read 400k instead of the default 1M.

Context window popover showing 59.3k / 400k (15%) with a colored progress bar, Plan usage limits Max (20x) below it, Session limit at 27%, Weekly all models at 36%, Weekly Fable at 0%, and a See detailed breakdown link at the bottom

Only after I see that 400k denominator do I paste my actual prompt.

The number. I use 400k.

In my observation, anything between 275k and 400k works well at Max effort. Going below 275k leaves the model too little room to think.

SettingNathan’s take
400kWhat I use
275k-400kGood band for Max effort (my observation)
Below 275kAvoid — too little thinking room

“Wait, didn’t you tell us never to auto-compact?”

Yes. I’ve said before to compact manually, at a clean stopping point, with a handoff doc written first. That advice still stands for interactive sessions on my own machine — where I’m watching the conversation and can pick the right moment.

Here’s the thing — an unattended cloud run has nobody at the wheel.

In the cloud, I let auto-compact fire at a ceiling I chose, and I use hooks to make sure every commit carries a handoff doc. Same habit, automated.

Now, I know what you’re thinking… won’t compacting mid-session make Claude forget important things?

That’s what the next fix is for.

.

.

.

Fix #2: Save Points Before Every Boss Fight

I learned this the hard way as a kid: skip the save before a boss, lose, and you’re replaying the whole level.

Long cloud sessions carry the same risk — a compaction squeezes the conversation down, and details about what the agent already built can get lost.

Every time Claude reaches a checkpoint — a feature done, a fix verified, a decision made — it commits. Before every commit, it writes a handoff doc with the progress so far. After a compaction, Claude reads the latest handoff and picks up where it left off.

The handoff is the save point.

Whiteboard-style diagram showing the save point flow left to right: a robot reaches a Checkpoint flag, writes a Save point on a notepad beside a floppy disk, presses Commit into a box, then context scatters during Auto-compact, and finally the robot reads the notepad under a lightbulb at Read and carry on — below, three small helper robots hand reports up to a developer giving a thumbs-up, labeled Helpers report back, with the banner Save before every boss fight at the bottom

Only the main session commits. Sub-agents report their work back, because a handoff needs the full picture of the session.

Setting this up takes three pieces.

Step 1: Tell Claude the Rules

First, add this block to your project’s CLAUDE.md:

## Handoffs- Commit at each **checkpoint** without asking: a unit of work (feature, fix,  decision) that is done and verified, or the point before switching to an  unrelated task. The handoff each commit carries is what survives autocompact.- Before every commit, run the `handoff-doc` skill to write a new handoff in  `docs/handoffs/` (`YYYYMMDD_NN_slug.md`, next `NN` for the day), and include  it in that commit.- Only the main session commits. Subagents report their changes back instead,  since a handoff needs the full session context.- After an autocompact, read the latest handoff in `docs/handoffs/` before  continuing. Read earlier ones too if the latest leaves gaps.

Instructions alone aren’t always enough.

A long unattended run can drift away from a written rule, especially after a compaction. So I back the rules with two hooks that fire every time.

Step 2: The Two Hooks

The bookmark runs right after a compaction.

It finds the newest handoff and tells Claude to read it before continuing. If there are no handoffs yet, it does nothing.

#!/bin/bash# SessionStart hook (matcher: compact): after a compaction, point Claude at the# latest handoff doc so it reloads the current project state.set -uo pipefailPROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"latest=$(ls -1 "${PROJECT_DIR}"/docs/handoffs/*.md 2>/dev/null | sort | tail -n 1)[ -z "$latest" ] && exit 0echo "Context was just compacted. Read the latest handoff before continuing: ${latest#"${PROJECT_DIR}"/}"echo "Earlier handoffs are in docs/handoffs/ if you need more history."

The gate runs before every command, but it only cares about commits. It refuses a commit in three cases:

  1. A sub-agent tries to commit — told to report its changes back so the main session can write the handoff and commit.
  2. The main session commits with no new handoff — told to run the handoff-doc skill, stage the new handoff, and commit again.
  3. A new handoff exists but isn’t staged — told to add it in the same commit.

Here are the key lines:

deny() {  jq -n --arg r "$1" '{hookSpecificOutput: {    hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: $r}}'  exit 0}grep -Eq '(^|[;&|(]|\s)git(\s+-[cC]\s+\S+)*\s+commit(\s|$)' <<<"$cmd" || exit 0if [ -n "$(jq -r '.agent_id // empty' <<<"$input")" ]; then  deny "Subagents don't commit. Report your changes back; the main session writes the handoff and commits."fi# ...deny "No new handoff in docs/handoffs/. Run the handoff-doc skill to write the next YYYYMMDD_NN_slug.md, stage it with this change, then commit again."

The full 55-line file is at require-handoff.sh on GitHub. It needs jq.

The cloudplay repository on GitHub open to the .claude/hooks folder, showing three hook files — post-compact-handoff.sh, require-handoff.sh, and session-start.sh — committed by nathanonn with the message Add handoff hooks and documentation for commit management

Step 3: Wire Them Up

The project settings file ties the hooks to the right events:

{  "hooks": {    "SessionStart": [      {        "hooks": [          {            "type": "command",            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/session-start.sh"          }        ]      },      {        "matcher": "compact",        "hooks": [          {            "type": "command",            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/post-compact-handoff.sh"          }        ]      }    ],    "PreToolUse": [      {        "matcher": "Bash",        "hooks": [          {            "type": "command",            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/require-handoff.sh"          }        ]      }    ]  }}
The cloudplay settings.json file on GitHub showing 34 lines with the SessionStart and PreToolUse hook entries, lines 12 through 31 highlighted in yellow covering the compact matcher entry for the bookmark hook and the Bash matcher entry for the gate hook

Two entries are new here:

  • The second SessionStart entry (with the compact matcher) is the bookmark — it fires after a compaction and points Claude to the latest handoff.
  • The PreToolUse entry (with the Bash matcher) is the gate — it checks every command for a commit and enforces the handoff rules.

The first SessionStart entry is last week’s tool setup.

Everything is already in the cloudplay repo. Use the repo as-is, or copy the instructions block, the two hooks, and the wiring into your own project.

Worth knowing: if you’re not using cloudplay, you’ll also need the handoff-doc skill. Stop Losing Work When You Compact Claude Code (The Handoff-Doc Skill) covers how it works.

  • /plugin marketplace add nathanonn/agent-skills, then /plugin install handoff-doc@nathanonn-agent-skills
  • Or: npx skills add nathanonn/agent-skills --skill handoff-doc

.

.

.

Fix #3: Run Five Sub-Agents at Once

This one surprised me.

The prompt I used asked for five sub-agents because it came from the Reddit post I built on last week. Logic would suggest that fewer agents should use less.

Honestly, I expected the one-agent run to be the frugal one. Then I watched it crawl along for days.

In my runs, it cost more.

The five-at-once session finished in a few hours. Together with the missing auto-compact cap, that slow run was part of what drained the week.

I have no statistics or proof for this. It’s purely my read after several cloud runs with Sonnet 5.5. Take it with a pinch of salt.

Why I think the long run costs more. I’m on Max 20x with Sonnet 5.5 — a combination where the five-hour session limit is meant to be much harder to hit. In practice, the weekly bar is the one that matters to me.

My theory comes down to two compounding costs.

The longer a cloud session runs, the more the context grows — and every turn carries that full context to the model. (Remember the backpack from the last section.) On top of that, the main orchestrating agent has to keep checking on the sub-agent’s progress for the entire run, and each check-in hauls that growing context along with it.

Think of the orchestrator as a supervisor paid by the hour to check on the work. With one worker, the supervisor is checking in for days. With five, the job is done by the afternoon.

Shorter runs mean fewer of those expensive trips. That’s why I switched to parallel agents.

Whiteboard diagram comparing one agent at a time versus five at once: the left panel labeled One at a time shows a single robot with an overstuffed backpack, calendar pages flying away, and a usage gauge mostly drained; the right panel labeled Five at once shows five robots running together, a clock, a sticky note reading Done in hours, a barely-used gauge, and a finish flag, with the banner Same job Different bill at the bottom

Here’s the revised prompt I use now:

I need you to launch five sonnet 5.5 sub-agents and help me build a triple A quality game that is a clone of "__game_name__". What I want you to do is I want you to launch these sub-agents, build the game without asking me any questions at all, and use ThreeJS to build the game.You will coordinate the work of the five sub-agents, ensuring that they are all aligned and working towards the same goal. You will also need to manage the integration of their work, ensuring that all components of the game are compatible and function together seamlessly.You can use "playwright-cli" to verify your own work.You may use "firecrawl" if you need to do any research about the game.The game should be frontend only for now. All the persistent data will be stored in local storage.Make sure the game is playable with mobile phone as well.Please create tasks for this first, and then assign sub agent to each task. You may run up to 5 sub agents at a time.Publish the game to Claude Artifact as you build, so that I can see your work.And once you're done, report back to me.

What changed from last week’s prompt:

  • Coordination paragraph — the main session owns integration and ensures components work together, which fits Fix #2’s rule that only the main session commits.
  • Mobile line — the game should be playable on a phone.
  • “Up to 5 sub agents at a time” — explicitly allowing parallel work.
  • Publish as you build — so I can see progress without opening the session.

.

.

.

Fix #4: Which Effort Level? (My Opinion)

This one is pure opinion, so treat it accordingly.

I mostly run Max. I’ve also tried xhigh and high with Sonnet 5.5. The results came out much the same, and I didn’t see a meaningful difference in usage between the three.

My reasoning for sticking with Max: the prompts I use are open-ended — “here’s the goal, go figure it out.” Most of the deciding is left to Claude, and higher effort gives it more room to think before it starts working.

The risk is overthinking and overbuilding (you know, like Opus 4.1, Sonnet 5 and Opus 5 used to). Honestly, for an overnight game build, I don’t mind if Claude overthinks, as long as the result is good.

EffortResults (my runs)Usage (my runs)
highSimilarSimilar
xhighSimilarSimilar
maxSimilar — my defaultSimilar
The Effort popover in Claude Code on the web showing Effort Max with a Faster-to-Smarter slider set near the Smarter end, Recommended label below the slider, and the composer showing Sonnet 5.5 and Max in the bottom right

Feel free to agree or disagree with this one. In fact, this whole post is based on feeling and vibes… so yeah.

.

.

.

What I’m Doing Now (and What I Still Don’t Know)

Four changes, each one copy-pasteable:

  1. Type /autocompact 400k before the prompt
  2. Commit at save points with a handoff, enforced by two hooks
  3. Run five sub-agents in parallel
  4. Pick an effort level and stop worrying about it

Here’s what I’ll be honest about.

These changes are new, and I don’t have numbers yet from a full week on the new setup. I’m making no savings claim. I’ll report back when I do.

Last week I said anything I can describe clearly enough can run while I sleep, on a machine bigger than mine. That’s still true — and now it has a budget.

👉 These four changes are how I run long cloud sessions now without watching my Claude Code usage vanish. Grab cloudplay, run a cloud session with these changes, and reply with what your usage looked like. If you’ve found your own tricks for keeping the weekly bar under control, I’d love to hear them.

Play them yourself. All five games are browser-based and work on mobile.

• 8 min read • The Art of Vibe Coding

Can Sonnet 5.5 Really Build a Full Game From One Prompt? I Tested It.

Can Sonnet 5.5 Really Build a Full Game From One Prompt? I Tested It.

A few days ago, u/Timisageek posted something on r/ClaudeCode that stopped me mid-scroll: Sonnet 5.5 one-shotting a full kart racing game. Five sub-agents turned a single prompt into a playable game in 67 minutes, with no follow-up messages.

I’ve seen plenty of “one prompt” demos that look great in a clip and fall apart the moment you click something. I’ve built features with sub-agents before, but a complete game from a single message?

That I had to see for myself.

So I typed my own version of the prompt into Claude Code on the web, set Sonnet 5.5 to Max effort, and went to bed. Zero messages while the session ran — no corrections, no course adjustments.

One prompt, then silence.

This is what was waiting in the morning.

Kart Blitz launch trailer showing karts racing through low-poly tracks built by Sonnet 5.5

The game is called Kart Blitz — an arcade-style kart racer where every model, track, and sound effect is generated from code. It took about five hours, and I never touched it once.

Want to try it first? Play Kart Blitz in your browser.

.

.

.

The Prompt

Here’s what I sent:

I need you to launch five sonnet 5.5 sub-agents and help me build a triple A quality game that is a clone of [a classic kart racer]. What I want you to do is I want you to launch these sub-agents, build the game without asking me any questions at all, and use 3JS to build the game.You can use "playwright-cli" to verify your own work.You may use "firecrawl" if you need to do any more web researchThe game should be frontend only for now. All the persistent data will be stored in local storage.Please create tasks for this first, and then assign sub agent to each task.Publish the game to Claude Artifact.And once you're done, report back to me.
Claude Code on the web showing the Sonnet Kart project with the Full Access cloudplay environment badge, Sonnet 5.5 at Max effort, and the full prompt before the session begins

The core ask came straight from the Reddit post (I’ve swapped out the name of the game it asked to clone).

I added a browser so Sonnet could check its own work visually, made Firecrawl available for web research, told it to plan tasks before launching agents, kept everything frontend-only, and added a step to publish the finished game as a Claude Artifact.

You can find the original prompt in the Reddit thread.

The browser was the most important addition — it would let Sonnet see whether its game actually worked.

Worth knowing: my prompt adds instructions and I ran Max effort where the original used High, so this is a variation on the experiment.

One-shot, as I’m using the word here, means one prompt from me, then silence until the report came back.

.

.

.

The Setup

My daily machine is a Raspberry Pi 5.

I’ve run a couple of agents at once on the Pi before, and everything else on it slowed to a crawl. Five agents building a 3D game — plus browser checks on top — was more than I wanted to throw at it. Claude Code on the web runs on someone else’s hardware, and I could close the tab and go to sleep.

Whiteboard comparison: on the left a tiny Raspberry Pi 5 board sweating and smoking under five robot agents and a browser window; on the right a roomy cloud machine carrying the same five agents and browser with ease

But a cloud session starts empty — a bare workshop with no tools on the wall. Without a browser, Claude writes a game it can never see running. It can run tests and check that the build compiles. Whether a road actually renders on top of the terrain or disappears beneath it — that takes eyes.

cloudplay is the setup that gives every cloud session my tools — including a browser — the moment it starts.

Stay with me: more on how that changes things at the end.

.

.

.

How Sonnet 5.5 Built It

Before launching a single agent, Sonnet 5.5 wrote the task list.

Sonnet 5.5's task plan showing nine checked items — lead agent creates the architecture contract and build pipeline, five builders handle world and tracks, kart physics, gameplay and AI, art and audio, and interface, then the lead merges and tests with a browser, publishes the game, and reports back

One lead agent set up the foundation and planned how the pieces would fit together.

Five builders then worked in parallel: tracks and scenery, kart handling, race rules and AI rivals, art and sound, menus and saved progress. Once they finished, the lead merged everything and moved on to checking the result. I’ve written about both halves of this approach before — planning the build in How to Make Claude Code Actually Build What You Designed and closing the loop in How to Make Claude Code Test and Fix Its Own Work (The Ralph Loop Method).

Because Sonnet had a browser, the lead agent opened the game after integration, took screenshots, and actually looked at what was on screen.

(This is the part that makes overnight runs viable — a model that can see its own output and course-correct without waiting for you.)

It caught four visual bugs — terrain covering roads, graphics glitches, buttons falling off a small window — and routed each one back to the builder that owned that section. All four were fixed before Sonnet reported back.

Sonnet 5.5's report describing how it created tasks, wrote the architecture contract, found four bugs in its own screenshots, and sent each back to the owning agent — ending with "All four were fixed."

.

.

.

What I Woke Up To

https://youtu.be/k7oO3ZLmPwE

The first thing I did when I woke up was open the session on my phone to see if it had finished.

It had.

Kart Blitz title screen displaying the game logo with a lightning bolt, Press Start button, and the tagline An Original Arcade Kart Racer

Kart Blitz.

An original kart racer where every model, sound, and track is generated from code — no borrowed names or art.

Here’s what five agents and about five hours produced:

Track selection screen showing eight tracks across the Sprout Cup and Ember Cup — Sunny Meadow, Dune Canyon, Frostbite Peaks, Neon Skyline, Coral Cove, Haunted Hollow, Volcano Rush, and Starlight Ribbon — with Sunny Meadow selected and its description visible
  • Eight tracks across two cups, eight drivers, 50cc to 200cc
Low-poly kart on the starting grid approaching the Start banner, with the lap counter at 1 of 3, speedometer at 0 km/h, and a minimap in the corner
  • Drifting with mini-turbos, 13 items, 11 AI rivals per race
  • Grand Prix, Versus, and Time Trial with a ghost to race
  • Keyboard, gamepad, or touch controls

The comparison.

Reddit runMy run
EffortHighMax
ToolsNoneA browser to check its work
Build time67 minutesAbout 5 hours
Tracks48
Automated testsNone reported308

My run took longer and came back bigger, but the prompts differed too, so the gap reflects more than the effort setting alone.

Sonnet’s honest report.

Sonnet 5.5's honest report listing what it could not verify — game feel, frame rate, the live link, physical devices, and audio quality — followed by the line "I would not call it triple-A. It looks like a well-made low-poly arcade racer."

One line from the report stood out: “I would not call it triple-A. It looks like a well-made low-poly arcade racer.”

Here’s the thing — that kind of honesty matters more than you’d think. When a model tells you exactly where its own checking stopped, you know where to pick up in the morning.

The report becomes your starting line.

My verdict.

Sonnet undersold itself.

The one thing it couldn’t test — whether a person would actually enjoy the game — is where it surprised me.

It’s genuinely fun.

The first proper race I ran, I won: 1st of 12 at Sunny Meadow, 100cc. I expected something that would look polished in screenshots and fall apart the moment I grabbed the controls.

It held up from the first turn.

Results screen showing 1st place finish out of 12 racers at Sunny Meadow, Sprout Cup, 100cc Versus mode, with a total time of 1:21.40 and best lap of 0:26.40

I tried it on my phone too.

Mobile view mid-race with touch controls — virtual joystick on the left, Brake, Drift, Gas, and Item buttons on the right, kart at 83 km/h on lap 1 of 3

The on-screen stick and buttons worked straight away — and Sonnet had only ever tested touch with simulated taps.

Think you can beat 1:21.40 at Sunny Meadow? Play Kart Blitz here. It runs in the browser on desktop and phone.

.

.

.

Why I Called It cloudplay

So, can Sonnet 5.5 build a full, playable game from one prompt with nobody stepping in?

Yes — given the right tools and about five hours of someone else’s compute.

The name breaks down into two halves.

  • Cloud: a bigger machine that already has your tools — Firecrawl for research, a browser to check its work — the moment the session starts.
  • Play: hand Claude the repo and a prompt describing what you want, and let it play out. It builds the thing, or at the very least tests out the idea you had in mind.

Either way, you wake up with something concrete to look at.

Whiteboard diagram breaking down the name cloudplay: cloud, a bigger machine with your tools already installed, plus play, describe the idea and let it play out

That combination changes what “using Claude” looks like in practice.

Before this, my habit was hovering over the session — approving each step, nudging the direction every few minutes. (I suspect that habit sounds familiar.) This time I typed one prompt, closed the laptop, and went to bed. The browser and the tools were already in place, so I could trust the session to catch its own mistakes while I slept.

Whiteboard comparison: on the left a tired developer hovering over a laptop, approving and nudging every step; on the right the developer asleep while Claude works in the cloud

I started this before bed and reviewed it in the morning.

👉 Anything I can describe clearly enough can now run while I sleep, on a machine bigger than mine. The honest report at the end means I wake up knowing exactly what was checked and what still needs a human eye.

A kart racer turned out to be a good stress test because it demands everything at once — visuals, physics, sound, AI opponents, menus, touch controls. That overnight handoff, from one prompt to a playable game and a detailed breakdown of what worked and what didn’t, is what the whole setup was built for.

If the tools can carry a game this complex on their own, they can carry most of the ideas I’d want to try.

Whiteboard flow from evening to morning: hand Claude the cloudplay repo and one prompt, sleep while Claude builds and checks its work in a browser in the cloud, wake up to a finished game and an honest report

Try cloudplay, run your own variation of the prompt, and reply with what you built.

• 9 min read • The Art of Vibe Coding

When WordPress Plugins Don’t Have a REST API, Build One (Temporarily)

When WordPress Plugins Don't Have a REST API, Build One (Temporarily)
Watch the video walkthrough, or read the full written guide below.

After Claude Code Can Talk to WordPress Now. Here’s What That Changes., I had the kind of momentum that makes you forget walls exist. Pages, templates, CSS — the entire site had deployed from one terminal prompt through the REST API.

That pipeline covers everything WordPress ships out of the box.

So I pointed it at something harder.

A team showcase with Advanced Custom Fields — a custom post type where each member gets a job title, a bio, social links, a photo, and a department.

ACF is one of those plugins that most serious WordPress sites depend on. It gives you real labels, tabs, and validation in the editor so the client can fill in fields without guessing what goes where.

Whiteboard diagram showing Claude Code connecting to WordPress via REST API (green checkmark), but blocked from reaching ACF configuration by a brick wall — no REST API for ACF config

And that’s where the momentum stopped.

ACF keeps its configuration locked behind admin screens. No REST endpoints for its internal objects. The only way in is built for humans clicking through a browser.

ACF does support the WordPress Abilities API — but using it requires setting up an MCP adapter alongside your site. I’ve covered that approach in Building WordPress Abilities API Extensions for Third-Party Plugins (SEO Edition) and I Built an AI-Powered Internal Links Plugin Using WordPress 6.9’s Abilities API and Claude Code. That works, but most plugins haven’t adopted the Abilities API yet.

What about a pattern that works for any plugin, right now, with zero extra servers?

WordPress admin Plugins page showing "No plugins are currently available" on a fresh install running version 7.1.1

.

.

.

The Bridge Pattern

Here’s the thing — the Code Snippets plugin has its own REST API. Claude Code already speaks HTTP. That single fact unlocks the whole approach.

Think of it as building a door in a wall.

The door exists just long enough to carry the furniture through. Once everything is inside, you remove the door. The room is fully furnished, and the wall looks like it was never touched.

Three-panel cartoon showing the door analogy — panel 1: install a temporary door in a wall, panel 2: carry furniture through, panel 3: remove the door and the room is furnished

Claude pushes a temporary snippet that configures ACF from inside, calls it, then removes it. The resulting post type and fields show up in ACF’s admin screens as fully editable — indistinguishable from something built by hand.

A developer opens the field group and finds real labels, tabs, and settings they can modify. (If you’ve ever spent twenty minutes clicking through ACF’s admin screens to set up a field group — naming each field, picking types, dragging them into tabs — you know the feeling of wishing you could just describe what you want and have it appear.)

Whiteboard diagram showing the three-step bridge pattern — Push a PHP snippet to Code Snippets, Call the temporary REST endpoint to configure ACF, Clean up by deleting the snippet

That’s the Claude Code ACF REST API bridge — a temporary connection between two systems that don’t natively talk to each other, powered by a plugin that most WordPress developers already have installed.

.

.

.

The Prompt

The prompt is shorter than you’d expect.

Site URL, masked credentials, and three tasks:

  1. Install and activate Code Snippets
  2. Install and activate ACF
  3. Set up a team showcase custom post type using ACF

One line at the bottom tells Claude to use the ask-first skill if it needs clarification before proceeding.

Claude Code terminal showing the prompt with site URL, masked credentials, and three numbered tasks — with callout labels highlighting the credential placeholders and the ask-first instruction

That’s the whole ask.

About those credentials: The username and password appear as placeholders — [WP-USER-82fd] and [WP-PASS-a706] — session-scoped stand-ins that replace the real values before they reach the transcript. That’s the credential guard from Your AI Agent Can See Your Passwords. Here’s How to Fix That. The AI works with a placeholder the entire session. The transcript stays clean.

Notice what the prompt leaves out.

Nothing about how the gap between WordPress and ACF gets bridged — no implementation plan, no intermediate steps. The prompt describes the desired outcome.

The skills figure out the rest.

.

.

.

Before It Builds, It Asks

Before Claude touches the site, it loads the ask-first skill and launches a structured requirements-gathering session.

Claude Code loading the wp-rest-api and ask-first skills, running preflight checks, and preparing to gather requirements — with "Skills loaded" and "Preflight clean" callout labels

Four questions, each with recommended defaults and room to customize.

The most interesting question is about fields — a multi-select checklist of what each team member should carry:

  • Core set (Recommended) — Job Title, Bio, Photo, Email, and Display Order for manual sorting
  • Social links — LinkedIn, X/Twitter, and Website URL
  • Phone + location — Phone number and Location/Office
  • Pull quote / fun fact — A short text area for personality

A freeform option lets you type in anything the presets don’t cover.

Claude Code ask-first skill presenting the Fields question as a multi-select checklist with four options — Core set (Recommended), Social links, Phone + location, and Pull quote / fun fact — all checked, with a navigation breadcrumb showing CPT naming, Fields, Taxonomy, Visibility, and Submit steps

The other three covered CPT naming, taxonomy, and visibility. All four answers appear together on a review screen before anything executes — one last chance to change your mind.

Claude Code ask-first review screen displaying all four answered questions — CPT naming set to Team Members / team-member, Fields showing all four groups selected, Taxonomy confirming Departments, and Visibility set to Public with archive — with Submit answers highlighted

By the time I hit Submit, Claude had gathered a complete specification — post type slug, eleven fields organized across four tabs, a hierarchical taxonomy, public visibility with an archive. Every detail confirmed before a single call touched the site.

(If you’ve ever built a custom post type and realized three fields in that you forgot to plan the tab structure, this is the step that prevents that.)

The ask-first skill is available in the agent skills marketplace:

/plugin marketplace add nathanonn/agent-skills/plugin install ask-first@nathanonn-agent-skills

Repository: github.com/nathanonn/agent-skills

.

.

.

Watch It Work

Let me show you what happens after you hit Submit.

Install. Both plugins go up through the WordPress REST API — Code Snippets and ACF, installed and activated in seconds. Claude reads the reference documentation and immediately spots the gap: ACF’s internal post types have no REST endpoints. The bridge pattern forms on its own — no hint in the prompt.

Claude Code installing both plugins via the WordPress REST API, then reading the Code Snippets reference and spotting the ACF gap — with "Plugins installed" and "ACF gap spotted" callout labels

Bridge. Claude writes a temporary snippet that registers a one-shot REST endpoint, pushes it to the site, and activates it. One call to that endpoint creates all three ACF objects — the custom post type, the taxonomy, and the field group with eleven fields across four tabs.

Claude Code writing and activating the temporary snippet — with "Temporary REST route" callout label

Clean up. Claude verifies the results through WordPress’s own REST responses — confirming the post type, taxonomy, and all eleven fields are wired and accessible. Then it deactivates the snippet and deletes it. The temporary route disappears from the site.

Claude Code deactivating and deleting the temporary snippet — with "Snippet removed" callout label

Done. The whole sequence — install, bridge, verify, clean — ran in a few minutes. I watched the terminal scroll and realized Claude had figured out the workaround on its own. I hadn’t mentioned temporary endpoints anywhere in the prompt. The skills gave it the tools, and the reasoning happened in real time.

Claude Code's completion summary showing all three tasks done — with "All tasks complete" and "Site unchanged" callout labels

.

.

.

What Actually Landed

Stay with me — this is where the bridge pattern earns its keep.

Time to check the WordPress admin.

Everything Claude configured is visible and editable through ACF’s own interface — the same screens a developer would use to build a field group from scratch.

ACF Edit Field Group page titled "Team Member Details" showing the fields table — with "Field group" and "4 tabs, 11 fields" callout labels

The field group — “Team Member Details” — organizes fifteen items (eleven data fields plus four tab separators):

TabFields
ProfileJob Title, Photo, Bio, Pull Quote / Fun Fact
ContactEmail, Phone, Location / Office
LinksLinkedIn, X/Twitter, Website
DisplayDisplay Order

A Team Members menu item sits in the sidebar with a Departments link below it for the taxonomy.

👉 Because the bridge went through ACF’s own configuration process, everything that landed is fully editable through the admin screens.

A developer can add fields, rename labels, reorganize tabs, change field types. The configuration lives where ACF expects it — in the database, managed through its own interface — so changes happen through clicks, the same way they would for any field group built by hand.

.

.

.

Adding Sample Data

With the custom post type in place, adding content is straightforward REST — no temporary endpoints needed. One prompt creates four departments and populates six team members with every field filled in.

Claude Code creating department terms via REST API — Leadership, Engineering, Design, and Marketing
Claude Code verifying all six team members with their ACF fields — job titles, departments, social links, bios, and live permalinks confirmed

Here’s the result in the WordPress admin — six members, each with departments assigned:

WordPress admin Team Members list showing all six published entries with Departments column visible

Open any member in the editor, and the ACF fields appear — four tabs, every field populated and editable with helper text that guides future editors.

(The kind of helper text that saves you from answering “what goes in this box?” every other Tuesday.)

WordPress editor showing Jordan Ellis as a Team Member post type — with "ACF meta box" and "Editable tabs" callout labels
WordPress editor showing the Contact tab with Email, Phone, and Location fields populated

From this point forward, everything runs on standard WordPress. Adding team members, editing fields, managing departments — all through the interfaces WordPress users already know.

.

.

.

Your Turn

Four steps to reproduce this on your own site:

  1. Install the skills from the agent skills marketplace
  2. Create an Application Password on your WordPress site (under your user profile in the admin dashboard)
  3. Copy the prompt template below, fill in your details, and run it
  4. Check the result — open the WordPress admin and look for your new custom post type, fields, and taxonomy

Here’s the prompt template:

Site URL: https://your-site.comAdmin username: your-usernameApp password: your-app-passwordInstall and activate the Code Snippets plugin and Advanced Custom Fields (ACF).Then set up a new custom post type for [your use case] using ACF.Use "ask-first" to clarify requirements before building anything.Use "wp-rest-api" to handle the deployment.

Install commands:

/plugin marketplace add nathanonn/agent-skills/plugin install wp-rest-api@nathanonn-agent-skills/plugin install wp-credential-guard@nathanonn-agent-skills/plugin install ask-first@nathanonn-agent-skills

Worth knowing — TasteWP gives you a free throwaway WordPress instance with admin access in about thirty seconds. Create one, generate an Application Password, and point the prompt at it. Zero risk to a production site.

The full repository is at github.com/nathanonn/agent-skills.

.

.

.

Drake-style meme — top: dismissive gesture next to "Clicking through ACF admin screens to set up custom post types, fields, and taxonomies one by one" — bottom: approving gesture next to "One prompt in Claude Code sets up everything from the terminal"

The Code Snippets bridge pattern works for any WordPress plugin that manages its configuration through admin screens without offering REST endpoints. ACF was the first test case, but the principle applies wherever a plugin’s admin UI is the only way in — product configurations, form builders, custom theme settings. If there’s an internal function that creates or modifies an object, a temporary snippet can call it.

Detailed workflow diagram showing eight steps — Write Prompt, Ask-First, Install Plugins, Push Snippet, Call Endpoint, Clean Up (grouped as "Bridge Pattern"), Verify, and Add Content — with the tagline "One prompt. Plugin configuration + content. Zero leftover code."

And here’s the kicker — each post in this series has quietly added a piece of the same toolkit. It started with How to Turn AI-Generated HTML Into WordPress Blocks (Without Breaking Them) automating block conversion, then the REST API post handled deployment and the credential guard locked down passwords. This post — the Claude Code ACF REST API bridge through Code Snippets — opens the door to plugins that were never built for automation.

What started as a copy-paste workflow now covers pages, templates, CSS, plugin configuration, and content. All from the terminal.

Point it at your next WordPress project and see what lands.

• 11 min read • The Art of Vibe Coding

Claude Code Can Talk to WordPress Now. Here’s What That Changes.

Claude Code Can Talk to WordPress Now. Here's What That Changes.
Watch the video walkthrough, or read the full written guide below.

You ask AI to design a landing page.

Thirty seconds later, you’re looking at a complete layout — hero section with gradient overlays, a pricing grid, testimonials, a multi-column footer.

The whole thing.

In How to Turn AI-Generated HTML Into WordPress Blocks (Without Breaking Them), I walked through what happens next.

You take that HTML and convert it into WordPress block markup — the kind the block editor actually understands. A validation skill checks every block against the editor’s own structural rules, the same checks it runs internally when deciding whether to show that dreaded “Attempt recovery” prompt. The output arrives clean. Native blocks, proper nesting, zero recovery prompts.

Then you open the WordPress block editor, switch to Code Editor view, and paste.

For one page, that works fine.

A cartoon meme of a frantic developer copy-pasting between an AI terminal and WordPress editor, surrounded by floating Cmd+Tab and Ctrl+V shortcuts

For a design that’s still evolving — tweaking the hero, adjusting spacing, swapping out a section — that copy-paste step becomes the bottleneck. You find yourself switching between the terminal and the browser every few minutes, doing the same mechanical steps with the same precision each time while the actual design decisions keep getting interrupted by the handoff. The whole rigmarole compounds when that cycle repeats ten or fifteen times during a single design review.

By the third round of design tweaks, I had the workflow memorized: generate, validate, switch to the browser, open Code Editor, select all, paste, switch back to visual mode, check.

When I caught myself reaching for Cmd+Tab before Claude had even finished generating, I knew the bottleneck had moved.

That August post ended right at the paste step: “Paste the validated markup into the editor.” The conversion, the validation, the structural checks — all automated. The paste step and everything after it? Still the old workflow.

The same Devlog landing page from the previous post — last time, we copy-pasted the output into WordPress

I kept running that workflow for weeks.

The validation skill caught every broken block before it reached the editor — a genuine improvement over debugging markup by hand. (The skill earned its keep on day one, and it kept earning it.) But every time I pasted a full page and switched back to the visual editor, the same thought kept surfacing. The paste step was the only piece still requiring a human body in a desk chair.

What if the AI could do the pasting too?

.

.

.

What If the AI Could Talk to WordPress Directly?

Here’s the thing — every WordPress site already ships with a built-in API. The block editor uses it behind the scenes every time you hit Publish or change a theme setting. Creating pages, updating templates, writing CSS to global styles — those endpoints are there, documented, and waiting.

It’s like finding a door between two rooms you’ve been walking around the building to reach.

All you need is an Application Password.

WordPress generates one from the admin dashboard, and it authenticates requests with a standard header WordPress already supports.

Whiteboard diagram showing Claude Code connecting to WordPress via REST API with Application Password — no MCP server, CLI, or SSH needed

The whole connection runs on standard HTTP requests and a credential WordPress generates in three clicks — the same kind of authentication the block editor itself relies on.

The idea: teach Claude Code how to use this API. Build a skill that knows where to send requests, handles the edge cases WordPress throws at you, and pushes everything — validated block markup, CSS, templates — in a single run.

Stay with me — talking directly to your site means the AI handles your credentials.

I covered that problem, and its solution, in Your AI Agent Can See Your Passwords. Here’s How to Fix That. The short version: a credential guard plugin masks the password the moment you type it and restores the real value only when a command actually executes. The AI works with a placeholder. The transcript stays clean.

That credential guard is part of the setup here.

.

.

.

Setup — Three Tools, Two Minutes

Three pieces to install.

If you followed the block validation post, you already have one of them.

  1. validate-block-markup — checks block markup against the editor’s own rules before anything ships. Catches broken blocks so invalid content never reaches your site.
  2. wp-rest-api — the skill that connects Claude Code to your WordPress site. Handles pages, templates, CSS, fonts — the full deployment pipeline.
  3. wp-credential-guard — a plugin that keeps your Application Password out of the AI’s transcript, using the credential masking pattern from the previous post.

The install is one marketplace command followed by three installs — all typed directly in Claude Code:

/plugin marketplace add nathanonn/agent-skills/plugin install validate-block-markup@nathanonn-agent-skills/plugin install wp-rest-api@nathanonn-agent-skills/plugin install wp-credential-guard@nathanonn-agent-skills
Claude Code terminal showing the marketplace add and plugin install commands with success messages

Once the tools are installed, you need an Application Password from your WordPress site.

Open the admin dashboard, navigate to your user profile, scroll to the Application Passwords section, and click “Add New Application Password.” Give it a name — something like “Claude Code” — and WordPress generates a one-time password you can copy.

WordPress admin showing the Application Passwords section with a newly created password

That’s the entire setup.

Two minutes, and Claude Code has everything it needs to deploy directly to your site.

.

.

.

The Prompt

The prompt is shorter than you’d expect.

Site URL, credentials, a reference to the HTML file, and three bullets:

  • Convert the landing page to block markup and validate everything before publishing
  • Create a front-page template with separate header and footer template parts
  • Push the CSS into global styles, with every class prefixed so nothing collides with the active theme
The full prompt in Claude Code — site URL, masked credentials, HTML file path, and three bullet points describing what to publish

That’s the whole ask.

No step-by-step instructions for how to connect to the site or what order to create things in. The skill handles the implementation; the prompt describes the outcome.

About those credentials: The username and password appear as placeholders like [WP-USER-f5b2] and [WP-PASS-fd2e] — session-scoped stand-ins that replace the real values before they reach the transcript. That’s the credential guard from Your AI Agent Can See Your Passwords. It masks credentials the moment you type them and restores them at execution time. The AI never sees the actual password.

.

.

.

Watch It Work

Let me show you what happens next.

Claude reads the HTML file, loads the three skills, and gets to work.

Claude loading the skills, running a preflight auth check, and confirming credentials work against the WordPress site

It converts the landing page to block markup section by section, validates every part against the editor’s own rules, then prepares the stylesheet and template. (Watching it validate each section in real time is oddly satisfying — like watching a row of locks click into place.)

Claude building block markup, validating all three parts, and creating the scoped stylesheet and front-page template

Then deployment. The page, template parts, and CSS go up to WordPress — each object landing where it belongs — and Claude sets the static front page.

Claude creating the page, pushing CSS into global styles, and setting the static front page

Instead of trusting that the deployment worked, Claude runs a pixel-level comparison against the original HTML design — and when differences show up, it tracks them down and fixes them.

Claude finding CSS differences from theme inheritance and fixing font-weight, letter-spacing, and text-wrap values
Claude's verification summary — a table showing all five objects deployed to WordPress (page, template, header, footer, CSS + fonts) and a pixel-diff comparison confirming 0 pixels differ at full resolution

A few minutes, five WordPress objects deployed, zero visual differences — from a standing start on a stock WordPress install.

When the pixel-diff came back at zero, I did what any reasonable person would do — I opened the browser and refreshed the page myself. Old habits. The landing page loaded exactly as designed, and I sat there for a second wondering why I’d expected otherwise.

.

.

.

What Actually Landed

We started with a stock WordPress install running the default theme. The homepage was the familiar “Hello world!” blog post. No custom pages, no templates, no design work of any kind.

A default WordPress install showing the "Hello world!" blog page with the stock Twenty Twenty-Five theme

And here’s the same site after one prompt.

The full Devlog landing page deployed to the same WordPress site — hero section, feature grid, testimonials, pricing, and a multi-column footer

The full Devlog landing page — hero section with call-to-action buttons, a feature grid, testimonial cards, pricing tiers, a CTA banner, and a multi-column footer. Custom navigation header. Custom footer matching the original design. All of it live, styled, and deployed from a single terminal prompt.

I asked for three things. What actually landed was five WordPress objects working together:

  • A page containing all the body content — hero, features, testimonials, pricing, CTA
  • A front-page template that wraps the page with references to the custom header and footer
  • A header template part with the full navigation bar, logo, and action buttons
  • A footer template part with the multi-column layout, link lists, and bottom bar
  • CSS and fonts registered in global styles, every class prefixed to stay isolated from the theme

The prompt described an outcome in three bullets.

The skill worked out what WordPress actually needs to produce that outcome — five objects, a full template hierarchy, scoped styles — and built all of it. (I wrote a prompt shorter than most emails.

The skill figured out the rest.)

.

.

.

Everything Is Editable

Here’s where this connects back to the thesis from the block validation post — a page is genuinely finished when the client can edit it themselves.

Open the deployed homepage in the WordPress block editor.

Every section shows up as a native block.

Click a heading — the sidebar controls appear with typography settings, color options, spacing adjustments. Select a button and the link, text, and style controls are all there in the inspector panel. The content behaves exactly like something built directly in the editor.

The Devlog homepage in the WordPress block editor with a heading selected and the Block sidebar showing typography and style controls

The navigation bar lives in its own template part. Open it separately, and you can edit the header independently from the page content — adding menu items, changing button text, adjusting the layout. The footer works the same way. Each template part is managed through the same interface WordPress uses for any site template, editable by anyone who knows how to use the block editor.

The real test came when I opened the editor and started clicking around like a client would.

Change a heading, swap a button label, adjust the spacing on a section — everything responded the way WordPress content should. That’s the part that matters more than the deployment itself.

The Devlog header template part open in the editor, showing the navigation bar as editable blocks with "Pricing" and "Add to your repo" buttons

👉 That’s the full arc: AI generates a design, block validation ensures the markup is sound, the Claude Code WordPress REST API skill pushes everything into WordPress, and the client opens the editor to find familiar, editable content. Click any block, edit the content, and publish.

From there, the handoff changes.

You give the client a WordPress site that works like every other WordPress site they’ve used. They update a heading by clicking on it, swap a hero image through the media library, and publish their own changes — without calling you. You move on to the next project.

.

.

.

Your Turn

Four steps:

  1. Install the three tools from the skill marketplace
  2. Create an Application Password on your WordPress site (under your user profile in the admin dashboard)
  3. Copy the prompt template below, fill in your details, and run it
  4. Check the result — the skill verifies the deployment automatically, but you’ll want to see it for yourself

Here’s the prompt template:

Site URL: https://your-site.comAdmin username: your-usernameApp password: your-app-passwordConvert this landing page into WordPress block markup: @path/to/your/index.htmlUse the "validate-block-markup" skill to check the markup before you publish anything.Then use the "wp-rest-api" skill to publish it:- Create a new front page template from the page body and set it as the site's front page.- The header and footer become their own templates.- The CSS goes into global styles. Prefix every class so nothing collides with the theme.Finally, use "playwright-cli" to open the live front page and compare it against the original HTML.

The full repository is at github.com/nathanonn/agent-skills. The skills work with Claude Code and other AI coding agents that support the skills format.

Worth knowing — if you want to test without touching a production site, TasteWP gives you a free WordPress instance with admin access in about thirty seconds. Create it, generate an Application Password, and point the prompt at it. Zero risk.

Whiteboard workflow diagram showing four stages — HTML Design, Block Validation, Deploy to WordPress, Visual Verification — with the tagline "One prompt, full site"

When I published the block validation post in August, getting an AI-generated design onto WordPress meant converting the HTML, validating the blocks, and pasting the result into the editor by hand. The credential guard post added protection for the password you’d inevitably type into a prompt. This post closes the loop — one prompt takes an HTML design and deploys the full site, with a visual verification that the live result matches the original.

The Claude Code WordPress REST API skill handles the deployment. Block validation ensures the markup is sound, and the credential guard keeps your password out of the transcript. Together, they turn a manual process into something you can run while you make coffee. The copy-paste bottleneck — the one I spent weeks working around — just disappeared.

And here’s the kicker — that coffee might still be hot when it finishes.

Point it at your next landing page and see what happens.