Statics lie

I spent a day catching my AI’s designs with my eyes. Every catch became executable code the same hour. That ratio is the story: my contribution was looking, and the machine’s job was to make each look unnecessary the next time.

The catches, in order. A tension ring whose wall thinned on the flanks, because the offset was applied radially instead of along the surface normal. A ring so oversized for its pipe that I asked what connection to reality the quality gates actually had. The answer was none. They checked printability and nothing else. A part could be flawlessly printable and useless for the thing it serves, and every gate would stay green. So now each generator must state what its part serves and check the fit against it, or the artifact gets renamed .FAILED and cannot sit in a folder looking ready.

Then the joint sockets. Twelve millimeters deep, and nobody, including the AI, could say why twelve. The cantilever arithmetic settled it: a 610mm bamboo rod with a 20 newton hand load at the end puts the printed socket wall at its crush limit at that depth. The derived answer is 24mm, so 24mm it is. And the bamboo itself: my sticks measure 5.8 to 6.2 millimeters; the designs had quietly assumed a quarter inch. Bores are now 7mm, with graded TPU shim rings taking up each stick’s individual variance.

The centerpiece was a snap-fit coupling that passed every static check with beautiful numbers. Seat clearance, detent alignment, all green. Then an adversarial verifier did something none of the static checks do: it swept the joint through its actual withdrawal path and measured the interference in motion. The answer was 0.001 millimeters. Zero hold. On a cone, pulling out opens clearance faster than the bump can chase the groove, so the interference the static check measured never occurs while the joint is moving. The part would have printed perfectly and held nothing.

The fix was structural: a cylindrical land that keeps the bump compressed while it exits, so the geometry cannot outrun it. The same sweep then measured 0.68 millimeters of genuine snap. Statics lie about dynamics. The acceptance test is now the sweep.

The same day, the first browser physics simulation went live: the marble chute I had printed the day before, running in a deterministic engine, the same code the QA gate runs, published with the gate’s verbatim log underneath. It answered the design’s biggest open question, whether the marble orbits the bowl or hops out of it. It orbits, with 10 millimeters of margin. The page says plainly that this verdict is a model until the physical marble agrees.

Which was the honest place to end when I drafted this: none of the new parts printed yet, the pour unproven, and a prediction that the first physical tests would catch things no gate measures, because that is what physical tests are for.

Then the draft overslept the Monday it should have shipped on, and the delay wrote the ending for me. The five graded shim rings were staged for the printer when a measurement of the emitted files caught the whole set 0.15 millimeters under the bore: every ring would have rattled in the hole it was supposed to grip. A sign error. The generator subtracted the squeeze where it should have added it, and its self-check passed the mistake because it computed the expected diameter from the same formula that sized the part. A part always agrees with its own declaration. The replacement check compares the ring against the bore constant, an external fact, and it earned its place the usual way: the bug was restored, and the check was watched to fail.

And the prediction itself came true, on a part that did get printed. It refused to take the actual bamboo stick, while a check literally named THREADABLE measured the channel’s slope and reported that the rod slides in without snagging. The rod did not go in. That failure is now a gate too: slice the emitted mesh, find the void at each height, and ask whether any straight line stays inside it the whole way, using none of the generator’s own variables.

The pour is still unproven. The system is not that I stopped making mistakes, or that the AI did. It is that each mistake now has to be made twice to embarrass us: once to be caught, and once more past the code that caught it. So far none has managed it.