I ran the robot factory by hand first

This post is about the moment the factory stopped being a diagram, because we ran the whole thing end to end. By hand.

What actually happened

While my AI usage limit was resetting, I did what I always do: walked every surface of the app on my phone, and this time took handwritten notes — eight pages of them, covering the landing page and every journey stage. Real founder-notebook material: cramped cursive, arrows, crossed-out words, sideways photos.

Then I photographed the pages and dropped them into the session. What happened next is the entire factory pipeline, executed manually:

1. Intake. The AI read all eight photos of my handwriting.
2. Triage. It transcribed them into 24 structured findings, grouped by surface, each one an actionable item rather than a scrawl.
3. Disambiguation. Four items it could not confidently read or interpret. Instead of guessing, it flagged exactly those four and asked. I answered each in a few words (“based on national avg,” “Professional jobs is not clickable”).
4. Tickets. The 24 findings became four batched tickets, grouped so each maps to one clean slice of the codebase.
5. Dispatch. Three scoped agents launched in parallel, each in an isolated copy of the codebase with a written ownership contract; a fourth queued behind the lane it shares files with.
6. Verify and ship. From there the machine we already built took over: the full test gate, the required end-to-end suite, the enforced merge script that refuses anything red, the post-deploy canary.

My total cost for 24 findings: one walk, eight photos, and four one-word answers.

Why running it by hand was the point

There is a rule in manufacturing: you do not automate a process you have never run manually, because you will automate your own ignorance. The dress rehearsal is where the process teaches you its real shape. Ours taught us three things the diagram version had wrong or missing.

The loop is batch, not drip. I had been imagining the factory as catch-by-catch: see a bug, file a ticket, spawn an agent. The walk revealed the natural founder rhythm is nothing like that. I walk everything, dump everything, clarify once, and then the whole batch fans out. One consolidated confirmation round instead of twenty-four interruptions. The automated factory has to ingest batches, or it will nag me to death.

Disambiguation is load-bearing. Four of twenty-four items needed my clarification. A factory that guessed instead of asking would have built the wrong thing four times, roughly one in six. That step — transcribe, flag what is uncertain, ask once, wait — is not politeness or ceremony. It is the difference between a factory and a fabrication line for plausible mistakes. It stays, permanently, whatever the autonomy level.

The bottom half already runs itself. From “ticket exists” downward, I was not needed at all. Dispatch, build, verify, merge, deploy, smoke: all machine. Every gate we built over the past weeks (the merge script that will not merge red, the end-to-end suite that cannot silently rot, the permission snapshot guarding the paid data, the canaries) is what makes unattended shipping safe. Which sharpens the remaining build enormously: the only thing left to automate is the top half — capture, triage, confirm, ticket. That is a much smaller machine than “build an autonomous factory” sounds like.

The metric that moved

The autonomy-levels post had a line I keep coming back to: high autonomy is not removing the human, it is moving the human from doing every step to deciding which direction to go next. There is a measurable version of that: how many useful actions the system takes per human instruction, and how many defects escape to the human anyway.

Look at this iteration through that lens. Twenty-four product improvements are shipping across four codebase slices, and my part was a walk, some photos, and four short answers. A few weeks ago, each of those findings would have been its own conversation, its own manual test run, its own merge. The ratio has moved an order of magnitude, and the defect side is moving the other way: almost nothing in my eight pages was a defect. The gates are eating the bug classes. What my walk produced was product judgment — this CTA is dishonest, this stage needs different content, this affordance promises something we cannot do. That is exactly the division of labour the ladder promises: the machine gets the correctness, the human keeps the taste.

What is left before it earns the name

Two things.

The small one is the top-half build: a capture channel that accepts whatever medium I actually use (handwriting included), the triage-and-confirm protocol we just field-tested, and automatic ticket creation. All of it now has a proven spec, because we ran it.

The big one is a decision, not a build. Once the factory can go from my note to a shipped fix, someone has to decide how much it ships without asking. File the ticket and wait for me? Build the fix and wait for my nod on the merge? Ship the low-risk classes autonomously and escalate the rest? That dial is the actual difference between level four and level five, and it is deliberately not the machine’s call to make. It is mine, and the honest answer is I will start it cautious and let it earn each notch — the same way every gate in this system earned its place: by being run, watched, and trusted only after it proved itself.