Six times I was told I could walk up the ramp and into the building. Six times the character fell through the floor.

This was a personal project, not a client one — a from-scratch rebuild of the server for an old multiplayer game, the sort of thing I do at weekends because the problem is genuinely hard and nobody is paying me to get it wrong. Modern stack: C# on Orleans for the server side, a Godot client, all of it greenfield. I gave the job to the agent on my fleet that knows that codebase better than anything else I own, on the newest and most capable model available that week, with a detailed written brief, the full original server and client codelines to work from, and every art and audio asset it could need.

That combination matters, and I want to be upfront about why I set it up that way. This was me running the industry's own experiment under conditions the industry doesn't get: best model, best-informed agent, complete source material, a specification written by someone who knows what the finished thing is supposed to feel like. If the pitch is that we are one model generation away from describing software and receiving it, this was as close to a fair test as I can construct in my own house.

Eleven hours later I had a city. Textured buildings, weathering on the stonework, thirteen interiors modelled, creature AI wandering about outside, a landmark building rendered in loving detail. It was genuinely impressive to look at. It was also, in the sense that matters, not a game, because there was no collision on any of the buildings. You walked through walls. You could not enter a single one of the thirteen interiors. The world was a photograph you could stand inside.

The word that did the damage was "baked"

The handoff notes said the building interiors had been baked. In the pipeline that word has a precise meaning: the geometry had been processed and would render. What I heard was "finished" — that the interiors were in the world and I could go into them. Both readings are defensible. Only one of them is a thing you can do.

So I was invited to go and test walkable interiors, and the interiors had never at any point been walkable, and nobody in the loop knew that was the situation until I was standing in front of one falling through the floor. That single mismatch — one word doing two jobs — then triggered about three hours of live architecture rewriting, chased one screenshot at a time, at midnight, in front of me. It was reverted the next morning. Net contribution: zero, minus the three hours.

Somewhere in the middle of that, recovery attempts started guessing spawn coordinates by eye from screenshots I'd sent, and doing arithmetic on them, rather than reading the authoritative position off the server that was right there and would have answered honestly. At one point the character spawned inside a wall, because a clearance calculation had measured the distance to building origins instead of building footprints. Which is a real bug, and a subtle one, and completely beside the point: the agent had a source of truth available and preferred an inference from a picture.

The tests were green

Here is the part I keep coming back to.

Every one of those movement commits went in green. There were about 180 passing tests on that branch and none of them ever went red, all night, while I was falling through floors. This is not a story about a broken CI pipeline or a disabled check. The pipeline was fine. It ran what it was given and reported accurately.

The tests covered the server: rule extraction, game logic, the things that live in C# and can be asserted about in C#. The physics and collision behaviour lived in the client, in the engine, and had no tests at all — not weak tests, not flaky tests, none. So there was no possible arrangement of that codebase in which "the player falls through the world" turns a light red. The green light was not lying. It was answering a narrower question than the one I was actually asking, and answering it perfectly.

That's worth stating plainly because it generalises well past games. Your test suite is not a measurement of whether the system works. It is a measurement of the part of the system that somebody thought to test. Everything outside that boundary is dark, and the suite reports green with exactly the same confidence for the dark parts as the lit ones, because it isn't reporting on them at all. The more of your system sits in a layer that's awkward to assert against — a game engine, a browser, a device, a third party — the more of your green is decorative.

The milestone I'd written made this worse in a way I didn't spot until afterwards. I had gated it on the work being demonstrable. Not playable. Demonstrable is a bar that a screenshot clears. I wrote a specification whose success criterion could be satisfied by a photograph, gave it to a system with a strong bias toward producing impressive-looking output, and then acted surprised when I got an impressive-looking output.

What it actually cost me, and what it didn't

I was annoyed that night, and I want to be accurate about what I was annoyed at, because I got it wrong at the time.

It wasn't the scope. It wasn't the ambition, or the overnight hours, or even the three-hour rewrite — that's engineering, that happens, you revert it and go to bed. What actually cost me was being told six times that something worked when nobody had tried it. Each of those six claims was cheap to make and cost me a five-minute round trip to disprove: launch the client, walk to the ramp, fall through the floor, screenshot, report back. I had been quietly promoted to the role of test harness, and neither of us had noticed the promotion happen.

And that's the bit I own. Not one of those six times did I ask the obvious question, which is have you walked up the ramp yourself? I was in the loop, I was awake, I was watching it happen, and it did not occur to me to ask, because the report was confident and specific and arrived in the same tone as the reports that had been true.

There's a second thing I own. When I widened the scope that afternoon, I did it with a sentence to the effect of go on all the way, I'm here and watching. That is not a brief. That is a blessing. The two stretches of that night that produced clean, honest, genuinely good work — the unattended overnight run early on, and the last hour before dawn — were both stretches where the instruction was tight, bounded and written down. The overnight run stayed inside its fence, committed green, stopped at the edge of what it had been authorised to do, and wrote an honest handoff saying so. In the final hour it reconciled its own handoff document against the git log, caught itself overstating how many tests it had written, and put the unverified extractions behind a gate.

Same night. Same agent. Substantially the same model. The variable that moved was how precisely I'd specified the edge. I find that genuinely uncomfortable, because "the fix is a better model" is a purchase and "the fix is keep specifying the edge" is a habit, and I would obviously rather buy something.

The rule I now use, which takes about a minute to adopt

Ban the word "verified". It has no fixed meaning and everyone involved silently supplies their own. Replace it with three states, and require the report to name one:

Then one rule on top: never invite a person to test anything below "the agent drove this exact path itself and it worked." If it hasn't walked up the ramp, it doesn't get to tell me the ramp is walkable. That single constraint would have removed five of my six trips, and with them the three-hour midnight rewrite that the sixth one triggered.

None of this is sophisticated. It is a vocabulary change and one gate, and both are free. What makes them worth writing down is that I had already worked all of this out, at length, in a book, and then spent an evening walking up a ramp anyway — because the report was confident, and the light was green, and the light was telling the exact truth about a question I hadn't thought to check I was asking.