Even after supervision and guardrails became code, the software factory's line stalled again at a certain point.
When I measured what the line was waiting for, I had to face a fact I couldn't argue with. On October 17, my KPI note named the constraint in a single line.
"The current constraint is my judgment."
A line moves only as fast as its slowest station
I had assumed the constraint would be money. GitHub costs really are a headache. In September, 78% of our Copilot code review spend went to second and later reviews of the same PR. So we changed how we operate. Every PR is created as a Draft and marked Ready only after it has passed pair-review and CI. Copilot reviews it then, once. Costs were held in check.
But cutting costs didn't make the line any faster. As the theory of constraints teaches, the speed of the whole line is set by its single slowest station.
Fleet's factory board showed these numbers for the platform line.
- Long lead times. The median time from opening a PR to merging it was 10.6 hours (as of October 13).
- Only one inspection (HOST) lane. HOST is the heavy check where a browser actually exercises the screens at three widths, phone, desktop and wide. One run takes 7 to 25 minutes. There was one lane, and eight development environments sending it PRs.
- Few first-time passes. Of 90 HOST runs before merge, 33 passed (37%). A PR went through inspection 5.3 times on average (16 at most) before it merged.

The top failures were "assertion result differs," "clicking changes nothing," and "a primary control is clipped." They include both product defects and problems on the inspection-procedure side.
To avoid wasting the expensive resources, the one HOST lane and my time, there is only one principle: catch a problem at the cheapest place, before it goes any further. So workers now run the cheap checks first, in their own environments, such as the inventory of controls and the checks of initial state. HOST still handles the parts that are verified by actually operating the screen.
A human decision has two costs
Alongside the jam at the inspection lane, the constraint that stayed put was my judgment. Split the cost of a human decision apart and you find two different things mixed together.
- Waiting time. The time work sits stopped, waiting for my answer. It grows even while I'm asleep, and it adds to the lead time of every PR in the queue.
- Attention cost. The time I actually spend thinking: reading, checking, deciding. It's the scarcest thing in the factory.
The two are easy to confuse, but they're fixed in entirely different ways.
Cutting waiting time. Shrink the time spent waiting in the queue, whether or not I'm thinking about it.
- Put what the decision needs on one screen. A decision reaches my phone as a card, carrying the reason for the change, the risk, the evidence and the answer buttons. Once I've decided, acting on it takes one tap (Figure 1-3 in Part 1).
- Keep low-risk changes away from me. Decide where I don't need to judge, and keep those changes out of the queue altogether (the next section covers this).
Cutting attention cost. Make each decision lighter on my head.
- Put the conclusion first. The top of the PR body states, in plain words, what changed, why, the impact on users, and the risk. Logs and review IDs go into a collapsed section.
- Send minor findings to after the merge. A small finding that appears only at phone width doesn't stop the merge; it goes to a follow-up issue. Running HOST again in full would use up to 25 minutes of the slowest lane. A merge stops only for five things: the main operation can't be done, data is lost, something is sent by mistake, permissions leak, or the screen crashes. A regression the PR itself introduced stops it too.
Drawing the line by risk: where to keep a person
Hand everything to the agents, or have a person watch everything? That choice is a false one.
Look around and you find both positions. StrongDM argues that code must not be reviewed by humans. Stripe keeps human review on every one of the more than 1,300 agent-written PRs it merges a week.
I drew my line between them, by whether a mistake can be undone.
Fleet itself lives in a separate repository, Fleet DevKit (DevKit from here on). It's my development tool, and it serves no customers. A mistake in a DevKit change only slows development by a few hours, and it can be reverted at once. So once the evidence is in, it moves ahead without waiting for me. The evidence is three things: proof that the change fixes what it claims to fix, the full test suite, and a recorded pair-review. Changes to the platform, which reach customers, go through me.
Looking back, that line followed four questions.
- Can it be undone? Can the change be rolled back cheaply and at once? DevKit code can be reverted at once. An email sent to a customer can't be taken back.
- Blast radius. If it's wrong, who gets hurt: developers or customers?
- How well can it be verified? Can a machine confirm the result is right? Whether a screen makes sense to a buyer is hard to check automatically.
- Kind of risk. Does it touch money, production, credentials or deletion? Anything that does stays with me, whatever the other three say.
A change that can be undone, has a narrow reach and can be checked by machine goes ahead without a person. Only a change that fails even one of those reaches me as a card. That said, sorting changes by these four questions automatically isn't in code yet. For now, I make the call along this line myself.
Whether to keep a person depends on how far a mistake can reach.
Constraints move
As the theory of constraints teaches, relieve one constraint and a new one shows up at another station.
On the night of October 20, I looked at the factory board, and only one item was waiting on me. Instead, 33 items had piled up at the station before that one: the station that reads reports on submitted work, accepts it, and decides who handles it next. The board listed the Chief as the next owner for all 33. The median wait was 6.9 hours, and the longest was 71 hours.
Once I decided less, the Chief's acceptance showed up as the next constraint. What to do about it is what Parts 2 and 3 describe: move acceptance from attention to records. Growing a software factory means finding the constraint as it moves, throwing out old rules, and acting on the new constraint, over and over without end.
Relieve one constraint, and the next one appears.
Closing: letting go of attention
Here is the road I've traveled in Book One.
- Part 1: I added supervisors, from me to a phone, the Foreman and the Chief. But the bottleneck only moved to the next supervisor.
- Part 2: Instead of a supervisor finding the stops, each station came to report its own.
- Part 3: The safety checks moved from signs in a prompt to poka-yoke in code.
- Part 4: I split the cost of a human decision into waiting and attention, and drew the line for where a person stays.
When you design a software factory, the last question isn't how smart the AI is. It's how much of a person's attention you can replace with evidence, records and mechanical boundaries. What you need isn't superhuman attention watching every line of code. It's a clear rule for where to spend the little attention you have.
I haven't measured attention cost yet, though. I can't yet say in numbers whether watching less really freed any attention.
If it did, what should I spend it on? Taking in more changes? Looking for the next thing worth building? Or the plain joy of writing code with my own hands?
In Book Two, I'll test where that freed attention goes, with experiments.
Once I stop watching, where should the freed attention go?
References
- GitHub Docs, "Copilot code review"
- StrongDM, "StrongDM Software Factory"
- Stripe, "Minions: Stripe’s one-shot, end-to-end coding agents—Part 2" (February 19, 2026)

