The second unit is harder than the first

What is missing from a prototype that a second copy immediately exposes.

A prototype only has to work once, in the hands of the one person who built it and already carries every small adjustment it needed in memory rather than on paper, while a second copy has to work without any of that memory present, which is exactly why building the honest second unit is so often harder than building the first.

Making one of something is a design problem, and making fifty of them is a completely different one. The first time I built a working prototype of a mechanism I was proud of, I got a stubborn part to seat properly with a few taps of a mallet and a bit of filing on one edge that I never wrote down anywhere, because I was the only person who was ever going to need to know it. It was only once someone else tried to build a second one from the same drawing, with no memory of that filing to draw on, that I understood how much of what I had assumed was a finished design had actually been finished in my own hands rather than on the page.

Why the first build is never actually finished

A prototype is the product of one person continuously making small judgment calls in real time while assembling it: this edge is a touch tight, so it gets filed; this hole lands slightly off, so it gets reamed a little wider; this cable is a bit short for the planned route, so it gets rerouted around a bracket instead of through it. None of those decisions is written down anywhere except in the finished object itself and in the memory of whoever made them, and both of those places are useless to anyone who was not standing there at the time. The finished prototype looks complete, because it runs and does the job it was built for, but that kind of finished is a different thing from being a repeatable design, since what a repeatable design actually needs is not the object at all, it is the instructions for producing the object, and a lone prototype only ever carries the result of those instructions, not the instructions themselves.

This is easy to miss precisely because the prototype gives every outward sign of being done. It sits on the bench, it moves the way it is supposed to move, and every visible measurement checks out against the drawing that supposedly describes it. What the drawing cannot show is the sequence of small departures the builder made from that same drawing along the way, each one reasonable in isolation and each one invisible in the finished part, so a design can pass every inspection anyone thinks to run on the first unit and still be, in the sense that actually matters, only half specified.

The sticking-door comparison

A door hung in a slightly rough opening almost never swings freely on the first attempt, so a carpenter plane the high spots down by feel, testing, shaving a little more, testing again, until the door finally closes flush without catching anywhere along its edge. Every bit of that fitting work disappears into the finished result: a visitor sees a door that closes properly and has no way of knowing how much timber was removed to get it there, or exactly where along the edge the trouble was. Cut a second, physically identical door from the same plan and hang it in a second opening framed to the same nominal dimensions, and the fitting has to start again from nothing, because none of the first door's planing travelled with it. The compensation was local to that one door and that one frame, and it vanished the moment the plane was put down.

Why hand-fitting disappears the moment somebody else has to build it

A design that will actually be reproduced needs the fitting captured in one of two ways: either the starting tolerance is held tight enough from the outset that no fitting is ever required, or the adjustment itself is written down precisely enough that a stranger can perform it without guessing, something closer to "insert to a depth of roughly this much, and if it stops short, ream by this much more" than to a vague instruction to make it fit. Skip both, and every later build reopens the identical trial-and-error the first builder already solved once, quietly, with their hands. The uncomfortable part of this is that the person best placed to build a second unit quickly, the original builder, is precisely the worst judge of whether the design is actually finished, because their own memory of the fix papers over the exact gap a truly independent build would expose immediately.

The one number worth remembering

Handed nothing but the drawings for a prototype and no access to the person who built it, a competent newcomer commonly needs several times longer to produce a working second unit than the original build took, and almost none of that extra time goes into anything the drawing got wrong on paper. It goes into rediscovering, one at a time and mostly by trial, every small compensation the first builder made without ever noticing they were making a decision at all.

What this changes in practice

The practical response is to treat the second build, not the first, as the real test of whether a design is finished, and to make sure it is attempted by someone who was genuinely not present for the first one. Handing a fresh set of drawings to an uninvolved colleague and watching where they stall is a far more honest check than handing the same drawings back to the original builder, who will unconsciously reach for the same fix without ever registering that the drawing never asked for it. Where that second build turns up a sticking point, the fix is rarely to shrug and note it down as tribal knowledge for next time, it is to go back and either tighten the tolerance so the fit stops needing rescue at all, or write the adjustment into the instructions with enough precision that the door, so to speak, closes flush the first time a stranger hangs it.

None of this is really about doubting the first builder's competence, since the compensations they made were usually the right calls, made quickly and correctly with the part in hand. It is about recognising that competence exercised silently is not the same asset as competence written down, and that the entire point of building a second unit, a hundredth unit, or a thousandth unit is that none of them will ever have the first builder standing beside them holding the file.