AI writes fast. The result still has to be as exact as a watch.
This page is how I make sure it is. Below, a movement comes apart and goes back together, one part at a time, and each layer is one check the work has to pass.
The typing is free now. The checking isn't.
The machine writes faster than I can read. Some of what comes back is ready to ship. Some is a decent first draft. Some is confidently, plausibly wrong, and that's the worst kind, because it looks finished.
Telling those apart, and fixing the almost-right ones, is the job now.
Take it apart. Then build it back.
Every part goes in on its own axis, in a set order. The movement stays still until the last screw is home. I want software held to the same rule: it runs when every check is in place, and not before.
Mainplate
Architecture, owned by a person
Everything else is screwed to it.
I own the design, the architecture and every decision. Agents do much of the implementation, in parallel branches, against a written plan. If the plate is wrong, every wheel on it is wrong, fast. So this part stays with me.
One TypeScript monorepo with one type system end to end. A change to an API type surfaces straight away in every client that uses it, which is how a three-person codebase became one about twelve engineers could work in.
The live-streaming platform case studyGoing train
Tests and determinism
Power goes in at one end. The same thing comes out every time.
Agent output is different on every run, so the checks around it can't be. I build deterministic gates for non-deterministic output: a test suite and a typecheck that every change has to pass.
All game logic is one pure function with a seeded random generator and integer-only maths. Same start and same commands give the same game, byte for byte, in the browser, on the server and in the AI. Several features could land in a day without each one quietly breaking the last.
The Tiny Tactics case studyEscapement
Review gates
Lots of energy, let through one exact step at a time.
An escapement is what stops all the stored power from leaving at once. Agents need the same thing. I write the rules before I see the work, the system enforces them, and risky steps wait for a human.
My open source tracker for parallel agents. Two agents can never claim the same task, a dependency graph says what's unblocked, and everything lands in an audit log.
More about cluNot running yet. Shown slowed down. At full speed: 18,000 beats an hour, escape wheel 10 turns a minute, fourth wheel 1, third 8 an hour, centre 1 an hour.
Now turn it over.
It keeps running while it moves. The dial goes on last, straight down its own axis, then the hands, one at a time.
Dial and hands
The finish people actually see
The only part most people ever look at.
Passing tests doesn't tell you it feels right. Agents drive a real browser for QA, and then I look at the result myself. Taste and judgment got more valuable with AI, because someone has to be able to look at a wall of plausible output and tell what's good.
Every button that starts a save shows an in-flight state, because on a phone in a gym a tap that looks dead is a bug. Nobody asks for that in a brief. You only get it by checking.
The Bikkel case studyRate
The Swiss watch is the reference
It can be stated exactly. A certified chronometer has to average between -4 and +6 seconds a day. Software has a daily tolerance too, counted in seconds of downtime. Pick a target.
8.64 seconds
of downtime a day, about 53 minutes a year
A chronometer's 10-second window
What it takes. Failover has to be automated, because nobody reacts in eight seconds. Redundancy across zones, instant rollback, and failure drills so you know it works.
Four nines is about as tight as a chronometer's window, though one measures drift and the other downtime. Nobody can guarantee 100%, so I pick a target on purpose before building and plan for the failure. Each extra nine costs more, and most products don't need five.
Where it still goes wrong
None of this makes the work safe by itself. The honest version:
It can look finished and be wrong.
That's the kind I look hardest for. An hour of generation buys raw material, and selecting, judging and killing the bad parts is still the work.
The rules can be wrong too.
Get them wrong and the whole fleet is wrong, fast. More autonomy means less live control, by design, so the judgment has to happen up front.
It isn't free.
Even simple tasks pass through several agents and burn tokens. Most teams will never need a self-managing fleet, and knowing which stage is enough is part of the skill.
More on this: Designing the factory, the long version. Process, from first question to launch. All the work. At night I make music videos, on YouTube, and pixel worlds, at taipei.gg.
Available for select projects.
Commission a movement
Tell me what has to keep running, and what it costs you when it's wrong.