Crew: one Claude Code session that runs an engineering team

In the last post my Claude Code sessions messaged each other as peers. Crew adds a lead: one session that never writes code, keeps a board, gives each item to its own worker session in its own worktree, and lands every item through a merge gate on the exact merged commit. Six crew runs on a private product boarded 635 items, and crew branches merged 534 times in 17 days.


TL;DR: Crew turns one Claude Code session into a lead that runs a team of worker sessions in Herdr. The lead never writes code. It keeps a board of items with dependencies, gives every ready item to a worker in its own git worktree, rules on questions, replaces workers that stall, and is the only session that talks to me. Every item lands through a merge gate that runs the repository’s full checks on the exact merged commit, so main stays green. On a private product, six crew runs boarded 635 items, and crew branches merged 534 times in 17 days. incr’s crews shipped its beta.10 and beta.11 releases; beta.11 went from plan to tag in about five hours. It broke in specific ways too, and the fixes that held were mechanisms, not written rules.

In the last post my sessions worked as peers: one per repository, each messaging the others when it needed something from their side. Crew puts one session in charge: a lead that decides what comes next, who owns each change, and what is allowed to reach main.

The shape

A crew has five parts.

  • Me. I give goals, product taste and the decisions that need my authority: production deploys, spend, brand. Technical calls and many product calls are delegated to the lead.
  • The lead. One long-lived Claude Code session. It starts worker sessions in Herdr, one tab per worker, and talks to them through Herdr. It keeps the board, answers questions, rules on scope and performance calls, replaces workers that stall or run out of room, and relays every result to me. I talk to one voice.
  • Workers. Each one owns exactly one board item and works in its own git worktree on its own branch. It reads the spec, builds, tests what it touched, reports back (done, question, blocked or hand-off) and lands the item through the gate.
  • The board. A plain list of items, each with an owner, a status, a target branch, a deliverable and its dependencies. Only the lead edits it.
  • The merge gate. Nothing reaches main until the repository’s full checks pass on the exact merged result.

The lead runs a check loop. Each pass reports finished work, workers that are blocked or have gone quiet, pressure on the machine, workers nearing their limits, leftovers from items that already landed, and items whose dependencies just landed. The lead acts on all of it in the same turn and loops again. Between passes it writes down its rulings, keeps a handover note, and runs a recurring reflection round that turns mistakes into enforced rules.

Life of an item

A crew starts from a plan or a list of items. The lead splits a plan into ordered items with dependencies, and an item becomes ready the moment its dependencies land; the lead assigns every ready item in the same turn rather than one at a time. A worker builds the item, and independent reviewer agents check its plan and its change. The worker iterates review rounds until the change comes back clean, and only then queues for the gate. One change ran 11 review rounds before it landed; another took seven in-branch rounds, all of them on race conditions.

Workers are not order-takers. I made the ruling explicit on 14 November: members act like accountable senior engineers, challenge the plan, and own the cost of what they run. A worker may push back on the spec or on the lead with evidence, and the lead rules on that evidence.

The gate is what lets many workers share one main branch. Queued items are merged together in a temporary merge and checked as a batch. If the batch is green, all of them land. If it is red, the batch is split until the failing item is cut, and the rest land without it. Main stays green, and the cost of a long check is shared by every item queued behind it. A gate is only valid for the commit it checked, so a main that moves mid-gate invalidates every running gate; bulk landings are batched and announced for that reason.

Sessions have limits, and a long item can outlast one. A worker that nears the end of its room writes a hand-off note; the lead closes it and gives the item, the worktree and the note to a fresh worker, which picks up where the first one stopped. The lead does the same for itself, passing the whole crew to a successor session.

One rule keeps all of this from leaving debris: whoever starts a tab, process, stack, worktree or branch removes it, and the lead sweeps leftovers on every pass.

Why the shape holds

  • The lead never writes code. Its context stays small and its time stays free for coordination. A lead that stalls stalls everything, so it is the one session kept off the critical path of any single item.
  • One owner and one worktree per item. No two sessions ever edit the same tree, ownership is never in doubt, and cleanup is mechanical.
  • The gate runs on the exact merged commit, in batches, with bisection. Main stays green, and one long check covers every item queued in the batch.
  • Ordered items with dependencies. A large plan becomes a graph, and work starts on each node the moment it can.
  • The machine is shared. On a small machine, the memory-heavy jobs (container stacks, browser checks, the gate itself) take turns rather than fighting.

Before crew there was an earlier multi-agent system of mine, retired in late October, with a merge queue, a verification stage on a real stack, ticket culture and sandboxed agents. Crew is lighter and lives in the terminal.

What it built

A private product

The product’s first waves, from 27 to 31 October, were built with parallel orchestrated chunks (16 chunks in one wave; 13 chunks and 28 fixes in the next). On 1 November the remaining waves moved to a Herdr crew, and the board history since then sits in six archived runs.

Across those 17 days, 534 merge commits name a crew branch. Some of the runs, by what they delivered:

  • The initial build crew finished on 3 November with all 94 of its board items done, plus an accessibility sweep of 1,786 scans over 893 states with zero accessibility violations.
  • A UX polish run landed 51 items on main on 5 November.
  • On the night of 14 November, five items landed overnight.
  • Docs and marketing pages ran as crew items too.

The crew also found real defects while building. One handler held a database transaction open across network calls, which stalled a database reset for more than ten minutes. The fix was made for the whole class rather than the one handler: every outbound call now goes through one boundary.

Commit counts say little about a crew, since every item lands as its own branch and merge; for the record, the repository took 7,511 commits over those 17 days (inferred from daily counts).

incr

incr, my open-source incremental-computation library in Rust with Python bindings, ran crews of its own. A week-long run in late October shaped the reflection loop described below; the beta.10 crew had 14 items, one large design split into eight plus an end-to-end item; beta.11 went from plan to tag in about five hours with three workers, shipping three requested features. The product’s crew filed its asks to incr as numbered requests, and the lead tracked that request page so none went stale. beta.9 to beta.12 were tagged between 15 and 17 November (beta.12 is a licence change). Measured on the product, hot standby takes over in 2.09 s against 434 s cold (about 800k output rows over 10 tables identical before the kill, after promotion and against a later cold hydrate; off by default, and a standby doubles memory), delta checkpoint nights take 0.7 to 1.0 s against 44.4 s and 48.1 s full writes, idle restart dropped from 70 s on beta.10 to 54 s on beta.11 on the same host and harness, and zero of 2,748,751 results were wrong against a recompute without incr.

A private library

A crew on a private library started with six items on 5 November and reached at least 20 by the next day. Items there got reviewed plans before any code. One plan section never came back clean after ten review rounds, so it was redesigned instead of patched again. A review on another item found file descriptors leaking into a concurrently started child process.

Where it broke

  • One shared slot set the pace. On 3 November, once only QA items remained, landings came about one every 50 minutes, and merges had to be moved ahead of queued sessions by hand.
  • Waiters polled a lock instead of queueing. One item waited over an hour while others jumped ahead of it. Arrival-ordered tickets fixed it.
  • Nobody questioned a wait. Three items waited 30 to 50 minutes on a slot whose holder sat idle editing code. The lead now questions every wait.
  • A bootstrap script reseeded the main checkout’s dev database. It printed database URLs but only wrote an env file; it now fails closed.
  • An orphan waiter came back to life. A restarted long-run waiter script was still alive. Because the shell re-reads a running script, it picked up its replacement’s edits and launched a duplicate load run once a lane freed.
  • The lead handed the crew back to me. A lead hit its own session limit, stopped, and told me to restart it; the crew sat leaderless with two workers stalled. Since then the lead swaps itself and its workers out and never hands the crew back.
  • I moved main mid-gate. Two streams of my own approval commits (124 and 91 of them) forced a roughly 40-minute gate to rerun twice.
  • A VM said “Running” while its port forwarding was dead, and every gate failed until it was restarted.
  • Builds over-ran. Workers rebuilt stacks and reran suites on every attempt until cached images, a stack kept running with hot reload, and tests scoped to what each change touched replaced that.
  • The single voice slipped. A worker published a page the lead never relayed, so I picked a logo by talking to the worker directly. The rule is now that everything comes through the lead.

Rules don’t stick; mechanisms do

The reflection round writes lessons down, and for a while the lessons only grew. The lesson file reached 432 lines (104 KB) while the largest classes of mistakes kept happening anyway. It was rewritten into 54 class rules (8 KB): each one names a class of mistake, not an incident. The cap comes with an escalation. When a class fails again despite its rule, the fix becomes a board item that builds a check into the tool, because a written rule had already shown it would not hold.

The lead needed the same treatment. It drifted: relays came late, cleanups came late, figures went stale. Several of my corrections became standing rules.

Limits

  • Gate runs take 21 to 45 minutes; incr’s gate takes about 45 under load. A main that moves invalidates them.
  • Session limits sometimes stalled workers before they could write their own hand-off note.
  • One small machine could run one heavy job at a time. Heavy work moved to a larger Linux box and a GPU box as they became available.
  • Not all effort is useful effort: one night’s audit found about 10 of 51 heavy runs wasted.
  • There is no controlled comparison against a human team or against a single agent, so I make no claim of a speedup multiple. What the numbers above show is what one lead, a board and a gate delivered, and where each of them failed along the way.