21,000 Lines of Code, Only Two Touchpoints: The Real Bottleneck in This Claude Code Pipeline Is People
Matt Pocock split Claude Code into five steps—grill, spec, build, ship, and retro—and delivered a 21,000-line feature in one go, with humans touching only two steps. Shoopy classifies this as graph engineering. The most important reminder: graphs give you breadth, but the cost lands on people.
Matt Pocock split Claude Code into a five-step pipeline. Shoopy posted the flow and a comparison image on X, saying the pipeline delivered a 21,000-line feature with humans touching only two steps.
The five steps are:
- grill: Have the agent ask questions back until every term has a name, then build 3 prototypes and keep 1.
- spec: Break it down into 47 user stories and 9 tickets, and avoid leaving undecided decisions to the agent as much as possible.
- build: One subagent per ticket, run in parallel, with humans away.
- ship: Split a large PR into 7 small PRs that can be reviewed and undone one by one.
- retro: Turn every review comment into a lint rule so the agent doesn’t make the same mistake next time.
Shoopy classifies this as graph engineering. The definition is plain: nodes do the work, edges do the routing, and state flows along the edges. A node is an agent that does only one thing, with its own context and tools; an edge is deterministic code that decides which path to take after classification; state is shared data, such as STATE.md, that records where this run got to, what was tried, and what was learned.
Shoopy’s article has a 4-question filter that’s worth putting up front: Will the task repeat? Do different failures need different handling? Should the agent writing the fix and the agent reviewing the fix be separate? Is the single-agent loop already the bottleneck? If any one of the four questions is “no,” keep using the loop. This judgment matters more than “go multi-agent.”
The most counterintuitive part of the pipeline is the first two steps. Parallel code writing looks like automation, but the really hard parts are grill and spec. Shoopy says in a reply that the two touches are the hard part: the grill stage decides what the thing actually is, and once every term has a name, the agent has little left to guess. The spec stage pins down 47 stories and 9 tickets, at the cost of humans making more decisions up front.
“zero decisions left to the agent” sounds beautiful, but someone in the comments reminds us that edge cases still need a clear owner; otherwise parallel tickets will confidently encode the same wrong assumption. That reminder is more durable than the pipeline itself. Decisions don’t disappear—they’re moved up front, and someone needs to sign off.
There’s another layer of cost that lands on people. In a reply, Volodymyr Gutorov says that going from a single loop to a multi-expert graph raises throughput, but it also adds more nodes that stop and wait for a human. Watching 4 to 5 Claude Code sessions itself becomes work, so he built Claude Mate: a small desktop device with a screen and LEDs that tell you which session is done, waiting, or error; press GO to bring the corresponding terminal to the front. The project has two versions, Arduino Nano USB and ESP32-S3 wireless, and a Python daemon on the Mac collects status through hooks or a PTY wrapper. It only brings windows to the front; it doesn’t collapse or resize them. It also works with the CLI. License: CC BY-NC 4.0.

There are two more terms in Shoopy’s article: comprehension debt and cognitive surrender. The more smoothly the graph runs, the more likely you haven’t read the code it ships. Gates rot; problems the test suite could catch six months ago may not be caught today. The mitigations aren’t technical: read every diff, spot-check the gates, limit the graph to small tasks that machines can verify, and find someone to design the graph with.
If you’re going to copy this, copy the order first: grill, spec, small rollback-friendly PRs, and retro turning into lint rules. Run it manually first, read diffs, trust the gates, then schedule it, then put it in a cloud Routine. Skip steps, and the graph will fail quietly and expensively.
If a single-agent loop works, don’t rush to put up a graph. A graph only makes sense when the loop is the bottleneck. A graph won’t fix a bad process; it will only amplify it—and make more people wait on you at the same time.
Reference links: Shoopy’s original post · Graph Engineering long-form article · Claude Mate
发布时间: 2026-11-19 23:36