A client's offer document had to fit on six pages. I rebuilt it, exported the PDF, counted the pages. Six. Correct, and completely useless. The signatures and the last row of the FAQ were sitting underneath the footer, shoved out of the visible area but still inside page six as far as a page counter is concerned. The counter was answering a question I had not asked. It tells you how many pages exist. It cannot tell you whether the content stayed inside them.
The only check that caught it was a screenshot of every single page out of a headless browser, looked at one by one. Four rounds of that before the document sat clean, and then the same four rounds again for the second document, because the first fix taught me nothing I could apply blindly.
The copy that was not the thing
Same week, different project. A multiplayer game, and a state change I wanted to confirm on a running server. I loaded the module from the console, set the value, read it back. It matched. Nothing had happened. Loading a module that way hands you a fresh copy of it, with its own state, sitting quietly next to the one the game is actually running. I had written into a shadow and then congratulated the shadow for agreeing with me.
The repair was to make the running code register a hook of its own, and to call the test through that hook. Not a prettier way to reach the module. A different module, the live one.
Measuring the ruler
Third one. Tests driven by synthetic keyboard and mouse events. Press a key, click, measure what comes back. Those events arrive one to three seconds after the tool sends them, and they do not arrive together, so holding a key down during a click is not something the harness can express at all. Every timing number that came out of those runs was a number about the harness.
The timings had to be taken from inside the game instead: the server stamps when the input landed, when contact was computed, when health changed. Done that way, the part of the delay that belonged to my own code was a minority of it. I had been one step away from optimising the rest, which belonged to the clock and to a network delay simulation I had switched on myself and left on. That setting survives between sessions, which is its own small lesson about test rigs that outlive the experiment.
What the three have in common
All of them passed. None of them could have failed. A page counter cannot report overflow. A private copy of a module cannot refuse a write. An input harness cannot outrun itself. Had the thing under test been broken in exactly the way I was worried about, every one of those checks would still have come back green, because none of them had a path to red.
The mirror image turned up in the same week. A cloned practice dummy dropped into the world refused to register hits, and for a while that looked like a real defect. Clones are simply not in the registry the combat code consults, so the test was reporting a failure that did not exist outside the test. False green costs a day. False red costs the same day and takes your trust in the tooling with it.
The rule I am keeping
Before trusting a check, describe what its output would look like if the thing were broken. If I cannot describe the failing output, I have not built a test. I have built a ritual that produces reassurance on schedule.
The cheap version of that is to break it on purpose once. Push a line of content past the footer and confirm the screenshot shows it hanging there. Write a value through the hook and confirm the game visibly reacts. A check that has been seen failing at least once is worth something. A check that has only ever been green is decoration with a progress bar.