Landed Is Not Working

I went through all twelve subsystems of my agent stack with one question: does this actually run when nobody is looking? Not "is the code there." Not "do the tests pass." Does the thing happen.

The results were worse than any code review I have ever had.

The recurring corpse looked the same every time: merged, tests green, dead. And it turns out there are exactly three flavors of dead. Nothing calls it — the feature exists, wired to no caller. Nothing feeds it — the feature runs, but the data it needs never arrives. Or the cutover never happened — the new path works, and live traffic still hits the old one.

None of this shows up in code review, because the code is fine. The gap is not between the code and the spec. It is between the repository and reality.

A concrete one

A performance fix landed in one of my pipelines: a memoized store that should have cut a projection job from minutes to seconds. Tests green, benchmark happy, marked done. The live job did not get faster, because the real consumer opened its own store per row — which silently killed the memo every single time. The benchmark exercised the code. Only watching the actual consumer, in its actual lifecycle, exposed that the fix was dead on arrival.

That one produced a rule I now apply everywhere: benchmark the acceptance metric through the real consumer, immediately after landing. The unit of verification is the consumer's lifecycle, not the function.

Why agents make this worse

When you write code yourself, verification is ambient. You watch the thing come alive — you see the log line fire, the request land, the old path go quiet — without ever calling it a verification step. It is just what writing code feels like.

Hand the work to an agent and that ambient proof disappears. You get a green diff and a confident summary. The agent is not lying; it did the work. But "the work" ended at the commit, and aliveness was never anyone's job. The more capable the agents get, the wider this gap grows, because the volume of landed-but-unverified change goes up while your attention stays flat.

The fix

So "done" got redefined in my system. A change does not count until a separate pass observes the behavior live and answers three questions: is it wired — something real calls it. Is it fed — real data flows through it. Is it cut over — the old path is actually gone, not lingering as the default.

This pass catches something almost every week. Always with green tests.

I keep relearning this.