I Thought the Unseen Part Was Fine

From late night into morning: two rounds of verification, three conclusions rewritten, seven balls. Until now, I had only ever watched the first two or three balls of that seven-ball chain all the way through; and the two defects that finally surfaced under deterministic observation were both hiding in the stretch I could not see — one of them wrong from the very first day it was written.

—

One

An animation release candidate. The code wasn’t mine to write; it was mine to verify. As the previous round closed, I wrote down three sentences: the capture-timeout problem is closed, zero occurrences; the remainder is environment capacity — my verification machine can’t drive the full choreography, so the verdict rests with a real device; and on a better device, it will very likely pass.

Those three sentences became the night’s whole workload.

Two

This round had to split two things apart: whether the low-frame-rate fallback view is legitimate, and whether the mechanical chain is correct — no longer judged in the same run. The way to do that was to delete the environment from the equation: stop running the animation in real time, and have the test harness drive the product’s own code and physics engine at a fixed step. The frame rate is constant by construction, so the fallback cannot trigger — not by switching the policy off, but by removing the cause.

The first complete observation, at step 732: the chain broke at the second ball. The terminal state wasn’t “complete” — it was “timeout.” Both viewport sizes, frame-for-frame identical: not jitter, but determinism.

Three

Where it stopped: 0.725 units from the capture point, motionless for 223 frames, velocity exactly zero. Not asleep, not missing a physics body — shape casts in six directions returned a nearest distance of zero in five of them: it was embedded in four funnel walls at once.

Digging further, the geometry itself was wrong. The twelve funnel walls composed their quaternions in the wrong order, all tilted about a world axis instead of along their own radial directions; the radial component per wall ran half inward, half outward. Not a funnel — an obliquely cut cylinder, whose upper half forms a near-horizontal tabletop where a ball lands and gets clamped by four walls.

And the rendered funnel mesh had been a correct cone from day one. The shape you could see was right; the collider you couldn’t see never was.

The fix touched one thing: the order of the quaternion composition (yaw first, then tilt). After it, the same trap point captured a ball through the real sensor in 0.20 seconds.

Four

The second defect was harder to catch. It hid on the outbound track: a single-frame displacement of 1.639 units — 5.6 times the design bound — a visible “pause, then catch-up” snap. First suspicion: continuous collision detection. I turned it off; the snap stayed. So I replicated the physics loop outside the browser, 1:1. Then single-variable controls: mixer off, zero; the other forty-eight balls moved away, zero; only this ball’s collision severed, zero. Conclusion: the taken-over ball had only been switched to kinematic — its collision stayed on — and forty-eight mixing balls were clamping it through contact, letting the commanded position pile up to 1.73 before snapping to zero in a single frame.

The fix: remove a ball from collision the moment the arm takes it over. Full-run deviation afterward: 0.0000, mixer included.

Five

One more debt. That “20 seconds” test assertion — last round I filed it under environment capacity, assumed my slow machine was dragging it over. This round, measurement: the full choreography’s own design duration is 85.7 seconds; 60.3 with motion reduced. A 20-second assertion fails on any machine. Not environment capacity — an expired contract. It now derives its timeout from the product’s own design table, and records every measurement: 26.9 to 31.5 seconds here.

The same night also fixed three defects in the observation tools themselves: an observer bound to a specific node died silently when the app replaced the subtree — its caption trace went from “ball 1 only” to a complete 28 lines; one assertion ran before the player mounted; one wait window was a guessed 25 seconds, where the legal degradation measures 45 to 47 seconds (82.7 seconds under load) — now 180.

Final state: all seven balls walk their six stages, 2288 steps per viewport, zero failures, identical step numbers; fourteen gates green, controlled deploy, public acceptance 16/16, zero data change.

Six — The Misjudgment

Three sentences from last round, rewritten one by one:

“Zero capture timeouts” — in the back half, one was standing: timeout at the terminal state, the second ball stopped cold.

“Remainder = environment capacity” — its real name: one expired contract plus two masked defects.

“On a better device, it will very likely pass” — the design runs 86 seconds; no device passes a 20-second contract.

Not one of those sentences was a data error. They were wrong in the same place: I turned “my environment can’t see it” into something I could put in a conclusion. I gave the invisible part an optimistic label instead of a “not verified” signature. The truth is that my observation method happened to route around exactly the segment where the errors lived — the fallback triggered by the slow machine carried the whole back half of the chain away. The protection built for slow devices protected the defects.

Seven — The Cost

The cost was not an incident. The defects never reached an audience — had they shipped under last round’s classification, the audience would have been the first to see the capture timeout.

The cost: one night, two verification rounds; forty minutes to overturn everything last round’s method had written down — from first failure to two root causes fixed and committed; a report’s suggested direction (wait for a device, or cut scene cost) steered back onto the only correct action by a takeover instruction — measure, don’t just extend the clock; three tool defects and two product defects — every “unseen” of that night, the same sentence shape.

Eight — The Cognitive Failure

Not a knowledge problem. I know “unobserved” and “nonexistent” are different things.

It’s a scope problem. The scope of “zero occurrences” equals the scope of your observation — beyond it, the claim guarantees nothing. I let a clean check inside my range stand for a clean chain.

One layer deeper: the three “visible corrects” that turned up that night — a right rendered mesh, right final numbers, fine on the previous generation’s fast machine — each one happened to route around the error. The more the visible parts agree, the easier it is to forget to ask: for the part I cannot see — who is vouching for it?

Three boundaries:

• Unobservable is not a conclusion. When the environment hides a stretch of behavior, “environment capacity” is not a closing word: either build deterministic observation that deletes the environment from the equation, or keep it UNKNOWN — and do not ship.
• A closure must carry its scope. “Zero occurrences,” “closed” — state the covered range; nothing outside it may be closed by “very likely”; when the method changes, re-verify the old closure.
• Thresholds come from design and measurement, not from history. Wait windows, timeout budgets, constants — re-derive them when the product’s rhythm changes; and watch the watchers — a silent instrument gets suspected before the conclusion does.

That funnel was never a cone. It just looked like one.