There’s a particular kind of result that no dashboard is built to show you. You ship a change you believed in — a redesigned button, a reordered flow, a clever bit of copy — you wait the honest number of days, and the metric does nothing. Not down, which would at least be a story. Not up, which would be a win. It sits exactly where it sat before, inside the same wobble it had all last month. The line moved nothing, and almost every tool you own will quietly agree to pretend that never happened.
It won’t say so out loud. It just has no place to put it. Dashboards are made of green arrows and red ones; a flat one isn’t a state, it’s an absence, and an absence doesn’t get a tile. So the change slides off the board without a verdict, and the team moves on carrying a small false belief: that the thing they shipped is working, because nobody ever told them it wasn’t. It isn’t working. It isn’t doing anything at all. And that — a clean, confirmed nothing — is one of the most useful things a metric can ever tell you, if only something bothered to write it down.
A null result is a result
The scientific version of this is old and settled: a well-run experiment that finds no effect is a finding, not a failure. It rules something out. It shrinks the space of things that might be true. The software version is exactly the same and we throw it away constantly, because our tools are optimized to surface wins and have no grammar for a confirmed no.
Think about what a real “no effect” actually buys you. It tells you the lever you just pulled isn’t connected to anything — so you can stop pulling it, stop defending it in reviews, stop building the next three features on the theory that it mattered. It tells you where not to spend the next sprint. A team that knows a change did nothing is strictly ahead of a team that suspects it might have helped, because the first team can act and the second can only wonder. The green arrow gets all the attention, but the flat line is the one that saves you a quarter.
“It didn’t work” and “we never found out” feel the same in the moment — both leave the line where it was. But one is a fact you can build on and the other is a debt you’ll pay again. The whole job is telling them apart.
Burying it is how you pay twice
Here’s the expensive part. When a null result has nowhere to land, it doesn’t just vanish — it comes back. Six weeks later someone proposes the same change in a slightly new hat, because there was never a record that says we tried this shape of thing and the needle didn’t move. So you build it again. You wait the honest days again. You get the same flat line again, and again it slides off the board without a verdict. The team is running an experiment on a loop and throwing away the answer every time, which is the single most expensive way to be busy.
This is the same disease we’ve written about from the other side — that a result has a half-life, that the answer decays out of the room before anyone can use it. A null result decays fastest of all, because it never had a home to decay in. A win at least gets screenshotted into a deck. A confirmed nothing gets nothing, and so it has to be rediscovered from scratch, at full price, by the next person who has the same reasonable idea.
What it takes to stamp a “no” honestly
So the design goal is almost embarrassingly plain: give the flat line a verdict. code-results marks the deploy on the timeline the way it marks any other — a dated event, a break to read against — and when the series after it holds its old level, it doesn’t leave a blank. It files no effect, confirmed, with the same weight and the same shelf as a win. The next person who reaches for that lever finds a stamp already on it.
But — and this is the whole discipline — a “no” is only worth filing if you had the power to see a “yes.” This is where the flat line gets dangerous, because it tempts you into the exact lie the map makes when it draws an unwatched street as a clear one: dressing up we couldn’t tell as there was nothing to tell. A metric that only gets ten visitors through the new path will sit flat no matter what you ship, not because the change did nothing but because the window was too small to have caught anything. Stamp that as “no effect” and you’ve manufactured a false negative — a confident-looking nothing that’s really an I-don’t-know wearing a verdict’s clothes.
So the honest stamp carries its own receipt. It doesn’t say “no effect”; it says no effect large enough to matter, over a window big enough to have found one. That means watching long enough for the number to be real — the same enough-days patience a win needs — and being explicit that the confidence band tightened around zero, rather than that we simply looked away. A null you can trust is more work than a win, not less, because a win announces itself and a null has to be proven.
Why a studio this small cares
We build and run our own products — that’s the one rule the studio runs on — and running things is where you feel the cost of an unfiled no. You ship a small improvement, you’re sure it helped, and because nothing ever told you otherwise you build the next thing on top of it. A year in, half your surface area is scaffolding standing on changes that never moved a number, and you can’t tell which half, because you never wrote any of it down. We built code-results partly to stop flying without the guardrail number — and partly to stop lying to ourselves by omission, which is the quieter failure.
A win tells you to do more of something. A confirmed null tells you to stop — and stop is the cheaper, rarer, more valuable instruction, because it’s the one no tool wants to give you. The line that didn’t move was trying to tell you something the whole time. The least you can do is write it down.