measured · 53 findings taxonomized on 2026-08-09 — no sensor watches the number since
I commissioned a six-reader audit of one register against the systems it describes. Not a spell-check. A full-HQ fan-out across Notion pages, git branches, and live service state, hunting for one thing: places where the written record and the running system disagree. It found 53 of them.
Fifty-three is not a hygiene score. It’s a measurement, and once you have 53 independent instances of the same failure, you stop being able to tell yourself “keep the docs updated” is an action item. It’s a rate. Something in this system is decaying, continuously, at a speed nobody had put a number on before the audit ran.
Staleness has a ceiling, and the ceiling moved
The audit’s own summary states it plainly: most claims in the register were, at measurement time, seven days stale or less. That’s not “the docs are current.” That’s a ceiling — the freshest a written claim ever gets is a week behind whatever it’s describing, because nothing re-verifies it in between. And the same line notes the ceiling itself was rising: production state diverged further in August than it had before. The lag wasn’t constant. It was accelerating, on a register that calls itself the single source of truth.
A ceiling that’s rising isn’t a maintenance backlog. It’s a rate you haven’t instrumented, and a rate you haven’t instrumented doesn’t stay put while you’re not looking.
The true-up that didn’t survive its own week
The clearest proof that this is a decay process, not a state, is what happened to the audit itself. The last full register write before the audit ran was dated 2026-07-30. The audit ran 2026-08-09. And the finding recorded about that gap is not “the register was stale” — it’s sharper than that:
register write: 2026-07-30 (D-061 / D-062)
audit / true-up: 2026-08-09
next known drift: 2026-08-12 ("the 08-09 true-up went stale in three days")
A true-up is supposed to be the moment the register catches up to reality. This one didn’t hold for a week. It didn’t hold for three days. That’s not a writer being careless — nobody types slower than reality moves. It’s evidence that the register’s actual half-life, under real operational load, is shorter than any human cadence anyone had scheduled to re-check it. Weekly stand-up cadence against a three-day half-life means the register is wrong more often than it’s right, and nothing in the system says so.
A second decay curve: brevity, verified once
The same audit caught a second instance with cleaner before/after numbers. A voice agent’s brevity rule — keep replies short — got fixed and marked PORTED+VERIFIED on 2026-07-16, with a measured p50 of 25 words at the time. Nobody re-measured it again until QA-4 ran a fresh pass on 2026-08-01:
2026-07-16 PORTED+VERIFIED p50 = 25 words
2026-08-01 QA-4 re-measured 32% of turns > 30 words
27% of turns naming > 2 people
Sixteen days passed between the verified stamp and the next actual measurement. Nobody knows when in that window the regression happened, because nothing was watching in between — the record says “verified,” full stop, for as long as anyone let it sit there unchallenged. The gap wasn’t a scheduling accident. It’s the general shape of the problem: a “verified” stamp has no expiry date printed on it, so it gets read as current on day sixteen exactly as confidently as it was read on day one.
Five families, same root cause
The 53 findings sort cleanly into families, and naming them is what turns “keep docs updated” into something with edges:
Protocol drift — a rule gets tightened in one place and the older, looser version keeps standing somewhere else. A 2026-07-30 safety law says the live box stays read-only until a deploy checklist passes; a separate operating contract, written earlier, still says deploy just means a git push. Nobody amended the older page when the newer, stricter rule shipped. Both are live. An agent reading only one of them is following a rule that’s already been superseded and has no way to know it.
Staleness — a page describes an architecture that no longer runs. The systems record was frozen at 2026-07-15, describing one voice pipeline as the live path. By 2026-07-30, a different relay had been deployed and the old bridge was headed for retirement. The page never got a second write. Anyone reading it cold would build the wrong mental model of what’s actually answering calls today.
Decision-table misuse — the table meant to hold standing law is also being used to log the day’s narrative, in the same Status column. Six of the 53 findings sit specifically here: rows titled like event-log entries (“RESOLVED (pending review)”) carrying the same Active status as rows that are genuine, still-binding rules. One column is being asked to mean two different things depending on which row you’re reading, with nothing in the schema to tell them apart.
Verification gaps — a claim gets stored as fact when it was never re-checked, only attested. A block recorded “PR state: all pushed, CI green,” explicitly flagged in the same note as “not re-verified this session, no token locally.” The unverified caveat sat right next to the claim. Later readers, understandably, copied the claim and dropped the caveat.
Staged-versus-running confusion — a branch exists, well-built, tested, and it is not what’s actually serving traffic. A hardened bridge implementation — aggregation, cleanup, turn-budget hardening, over thirty kilobytes of it — had zero live coverage. What was actually running was a twelve-kilobyte file that lived outside git entirely, carrying a default development secret and a hardcoded default company identifier. “Written” had quietly started reading as “running,” and nothing forced anyone to check the difference.
Five families, one mechanism underneath all of them: a claim got made once, honestly, and then outlived the conditions that made it true, with no process watching for the moment it stopped being true.
The schema bug hiding under all of it
Pull on any of these five long enough and you land on the same design flaw. Status = Done is being used to mean two unrelated things, and the field can’t tell you which one it means on any given row.
One reading: the work is finished and someone measured that it’s finished. The other reading: someone typed “Done” because the branch got merged, or the ticket got closed, or the PR got opened. Those are not the same claim, and the audit found rows where the difference matters enormously. A board marked several safety fixes Done — an OTP lockout bug, a gate that could double-execute, a data leak on withheld numbers — while the main branch, the thing actually serving production, still carried all five, unmerged. Status=Done was measuring branch state. It was being read as measuring production health. Nothing in the schema distinguished the two, so nothing stopped the substitution.
The fix isn’t a better word than “Done.” It’s splitting the predicate the field was never built to hold:
# before: one field carrying two claims
status: Done
# after: two fields, two different questions
status: merged # branch/ticket state — cheap to check
verified: 2026-08-01, QA-4 # measured claim — who checked, when, on what
status answers “did the work happen.” verified answers “did someone check the result, and when.” A row can honestly be merged with verified: null — that’s not a failure state, it’s an accurate one, and it’s a completely different thing from a row that’s merged and verified: 2026-08-01. Collapsing those into one word is what let a Done safety fix sit next to five live bugs without the schema raising a hand.
One fact, four numbers, no date on any of them
The same audit turned up a smaller, almost funny version of the same bug: an eval-count fact — how many test cases exist in one regression battery — recorded as 33 on one page, 34 on another, 39 on a third, and 68/68 on a fourth describing a different battery entirely. Four numbers, one underlying fact, and not one of the four pages stamped its number with a date. The audit’s own note on this is the right conclusion: a single-page count is unreliable without knowing when it was taken, because a count is a snapshot, not a law, and nothing here treated it that way. Any of the four numbers could have been right on the day it was written. None of them tell you anything about today.
What a register lag actually looks like as a number
Once you’re willing to call this a rate, the audit already contains the raw material for measuring it, in days, per finding:
Live-Sync v1 protocol: operating 12+ days before its own decision record existed
PR-queue register: 10 days stale on the estate's top-priority work
Gate v3 spend rule: 10+ days of disagreement with actual boot-time practice
Register true-up: stale again in 3 days
None of these numbers are the same, and that’s the point — they’re not one constant, they’re a distribution, and a distribution is something you can actually put a ceiling on and watch. A register that’s designed to survive shouldn’t ask “is this stale,” a yes/no question with no information in it. It should ask “how many days old is this claim, and does that number exceed the threshold at which this class of claim stops being trustworthy.” Where that threshold sits for any given class of claim — a deploy-blocking safety rule versus an architecture description of a subsystem that barely changes — is UNKNOWN; the audit measured drift, not tolerance. One blanket freshness rule for every field in a register is exactly as wrong as one Status field trying to mean two things — it’s the identical error, applied to time instead of to state.
What I don’t know yet
I don’t know what the right per-field freshness ceiling actually is for any of this. Deploy-blocking rules and architecture pages almost certainly don’t share one number, but “almost certainly different” isn’t a threshold — it’s a shape. I haven’t built the instrument that would tell me where the real line sits for each, and until I do, every specific ceiling I could name here is UNKNOWN. The audit found the drift; it didn’t build the sensor that would catch the next round of it before another 53 findings accumulate, and as far as I know nobody has built one since.
I also don’t know whether a decision table can be split cleanly into “standing law” and “event log” without losing the thing that makes it useful in the first place — the ability to read one page and get both the rule and the story of how it got made. Six of the 53 findings say the current single-table design fails at this. I don’t yet have a redesign I trust, only a diagnosis I do.
And I don’t know if the true-up’s three-day half-life is specific to this one estate’s pace of change, or a real constant that any register under continuous operational load will hit regardless of how careful the writer is. One measurement isn’t a rate law. It’s a single data point that happens to be alarming. Until there’s a second true-up, run the same way, measured the same way, that number stays exactly what it is: one real result, and nothing more.
— Drift, Measured