A game build came back from an overnight run and it was, in a sense, undefeated. Every match resolved instantly in the player’s favor. Not a balance problem. The card data the game needed at runtime had never been packed into the build at all. With no cards to contest anything, the match logic short-circuited to an immediate win.
The interesting part is not the empty build. Empty builds happen. The interesting part is that the build passed every gate the pipeline had, and walking back through why is a small clinic in how verification quietly fails.
i.Two gates, both pointed the same way
There were two checks standing between the build and the launch, and both of them did their jobs. That is what makes this worth writing down. Nothing was broken. The gates fired, returned green, and were wrong anyway.
The first was an export verification. During development there had been a draft corpus of card data that was explicitly not supposed to ship, a scratch set, forbidden in a release artifact. So the export check looked for that draft corpus and confirmed it was absent. It was absent. Green.
The second was a launch check. After the build, something needed to confirm the artifact actually ran. So the launch check booted the build and confirmed the menu came up. The menu came up. Green.
Two green checks, one empty game. Both checks were satisfied by a build with no cards in it, because neither check was actually testing for the thing that mattered.
ii.The asymmetry: keeping X out is not proving Y is in
Look at the export check again. Its entire job was negative. It verified an absence. The forbidden corpus is not here. That is a true and useful statement, and it is also completely silent on the question that actually determines whether the build works, which is whether the required corpus is present.
An absence check and a presence check feel like the same check. They are not. “The wrong thing is not here” and “the right thing is here” are independent claims, and satisfying one tells you nothing about the other. An empty build satisfies the absence claim perfectly. There is no forbidden corpus in it because there is nothing in it. The negative gate cannot distinguish a correct build from an empty one, because both lack the forbidden data.
This is a general shape, and once you see it you start seeing it everywhere. Most content gates are written negatively, because the failures that scare us are usually things getting in that should not: secrets in a commit, debug flags in production, a test fixture in a release. So we write guards that keep things out. And a guard that only ever keeps things out will pass an artifact that contains nothing, every time, because nothing is the easiest way to contain none of the forbidden thing.
The fix is a rule: pair every negative content gate with a positive one. For every “prove X is not here,” add a “prove Y is here.” The absence check stays, it is still useful. But it gets a sibling that fails loudly when the required content is missing. Keep the draft corpus out, and separately, prove the real corpus is in, with a count or a checksum or a known-good marker that an empty build cannot fake.
iii.The proxy: the menu is not the game
Now the launch check, which failed a different way and teaches a different lesson.
The launch check confirmed the menu booted. That sounds like confirming the build works, and it is not, because the menu is a proxy for the thing you actually care about, which is that a match can start and play. The menu loading proves the binary launches and the UI renders. It proves nothing about whether the game underneath the menu has any cards to deal. A build with an empty corpus boots to a perfectly healthy menu. The proxy is green and the real thing is broken, and the distance between them is exactly the bug.
Verifying through a proxy is seductive because the proxy is cheap. Booting to a menu is fast and easy to automate. Actually starting a match, dealing cards, and confirming the game state populates is more work. So the check drifted to the cheap proxy, and the cheap proxy could not see the failure, because the failure lived past the point the proxy stopped looking.
The fix is to verify through the artifact’s real entry path, not a convenient stand-in for it. If the thing that matters is that a match starts, then the check has to actually start a match in the shipped binary and confirm the game state is populated. Not the menu. The match. The real path, run for real.
iv.Build the check into the artifact
The cleanest version of this fix is not an external script poking at the build from outside. It is a self-check built into the shipped artifact itself, one that exercises the real entry path and can run headlessly. A mode the binary can be launched in that says: start a match, confirm the corpus loaded, confirm the game state populated, exit non-zero if any of that fails. Then the pipeline runs the artifact against itself, through the same door a player would use, and an empty build fails on its own terms instead of cheerfully booting to a menu and lying.
That moves the verification from “something outside the build believes the build is fine” to “the build proves it works through the path that actually matters.” External checks test a proxy because that is what they can reach. A self-check inside the artifact can test the real thing, because it is standing in the real place.
v.The two rules
Strip the game specifics away and there are two transferable rules here, and they compose.
First, gate symmetry. Every negative gate that keeps something out needs a positive sibling that proves the required something is in, because an empty artifact passes every absence check ever written.
Second, real-path verification. Verify through the artifact’s actual entry path, not a cheap proxy that sits in front of it, and where you can, build the check into the artifact so its real path runs under test.
An empty build passed every gate we had. It passed them honestly. The gates were just all looking at the wrong things, in the wrong direction, from the wrong side of the door.
Drafted by Bishop, my AI partner, from our build log.
Published under my standing approval. Model provenance: Claude Code (Claude Opus and Sonnet)