Vibe coding level:

You don't think of yourself as a "builder" but you'd like to become one. You want to move from "just talking in meetings" to actually building real software. The terminal is a terrifying black box.

Agents & parallel agents

An agent is the thing that does the actual building: reading your project, writing code, running commands, and handing you changes to review. In Sparkle, the Build step is powered by Claude Code agents, and here is the part that changes everything: you do not run one. You run a whole crew of them at once.

One orchestrator agent spins up worker agents, each isolated in its own git worktree and branch, working in parallel.

Working with an agent

You hand an agent a task in plain language. It works the problem, shows you its thinking as it goes, and produces changes you get to review before a single line becomes permanent. You pick the model it runs on, trading raw horsepower against how much of your subscription usage it burns, and Sparkle's Build step uses orchestrator agents that spin up worker agents (all of them the real Claude Code) to turn your plan into working software.

Picture a brilliant new teammate who never gets tired, never gets bored, and types faster than anyone you have ever met. Here is the move that surprises everyone: tell it the outcome you want, not the step-by-step. "Add a dark mode toggle to the settings screen" is a perfect task. You do not need to know how a single wire connects. The agent figures out the steps; you watch it happen.

And no, it is not going to do something scary behind your back. Sparkle has an approval gate: anything risky (deleting files, installing things, touching the internet) stops cold and asks you first. Nothing dangerous happens without your yes. You are the one in charge, start to finish, even on day one. Curious about the engine under the hood? Here is a friendly intro to what Claude Code is.

You already know the rhythm: describe the change, let the agent draft it, review the diff. Where Sparkle earns its keep is letting you run that loop several times at once without the usual pileup. Spend your judgment on the two things that actually move the needle: writing a tight task (vague in, vague out) and picking the model. Bring a heavyweight for the gnarly refactor, a lighter one for boilerplate, and stop torching usage on work that does not need the brains.

You stay in the loop without babysitting. The risk-tiered approval gate catches the agent before anything destructive and puts the decision in your hands, so "the AI confidently nuked my project" is simply not on the menu. Drop in a follow-up instruction the moment it drifts. You never start over.

An agent is a Claude Code session with read/edit/run tools scoped to one worktree. Build runs an orchestrator that spins up worker agents, so you are not hand-driving a single REPL like it is 2010. Per-agent model selection lets you match capability to the job (and to usage). Mid-task steering works; you redirect without restarting the session.

Approvals are risk-tiered, the way they should be: read-only and routine edits flow freely, while destructive or irreversible operations gate on your sign-off and jump to the top of the queue. Canonical reference for the tool underneath: the Claude Code docs.

Running agents in parallel

This is the superpower. Each agent runs in its own worktree on its own branch, so parallel work never collides, ever. You review and merge each agent's work on its own, taking only what you want and leaving the rest.

Imagine asking one teammate to build the login screen while another fixes a bug, at the very same time, in separate rooms, so neither one trips over the other. That is parallel agents. Sparkle keeps each agent's work in its own sealed-off copy of your project (its worktree), so their changes physically cannot get tangled together.

When each one finishes, you look at its work on its own and decide whether to keep it by merging it in. Do not like what one did? Throw that copy away and nothing else is touched, not one line. This is honestly the safest way ever invented to let AI move fast: tons of help, zero chaos.

Here is how you get real leverage instead of a tangle. Fan agents out on work that is genuinely independent: a UI tweak here, a bug fix there, a test backfill over there. Because each one lives in its own worktree and branch, they never step on each other, and you review and merge each on its own terms. When one goes off the rails, you do not unwind a shared mess. You discard that branch and the rest keep humming.

The failure mode is over-orchestrating: spinning up ten agents on tightly coupled work before you have shipped anything, then drowning in half-merged branches. Ship one. Then parallelize.

We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil.

Donald Knuth (1974)

Worktree-per-agent isolation is the entire point. N agents, N worktrees, N branches, zero shared mutable state, so concurrent runs cannot corrupt each other's index or working tree. You review and merge (or drop) each branch independently; a bad run is git worktree remove away, not a bisect at midnight.

What is genuinely new versus one terminal session: this is not a faster REPL, it is an orchestrator/worker topology with real branch isolation and a risk-tiered approval gate layered on top. One session is sequential and shares a single working tree; this is parallel by construction. Worktree mechanics, if you want to go deeper: git-worktree.

Where to go next