Day 2 of 14 — Structure Over Vigilance. Pete Gypps, COR Intelligence.
Yesterday I said we keep putting the guarantees in the wrong place — in vigilance, in remembering, instead of in structure. Today I want to make that concrete, because it stays abstract until you've watched it happen. So here's how it happens. It's a small story, and the smallness is the point: nothing dramatic goes wrong, nobody's negligent, and the system rots anyway.
The story — invented, because the real ones aren't mine to share
Picture a business that keeps its master record of a company in one verified place. Legal name, company number, registered address — all sitting in a single record someone checked and trusts. That's the source of truth. So far, exactly as it should be.
Now picture that somewhere, to make a bit of work go quicker, someone copies the legal name out of that record and into a project file. Not the whole record. Just the name. It's a completely reasonable thing to do. It saves a lookup. It feels like efficiency, because in the moment it is efficiency.
Six months pass. The master record gets a correction — a small typo in the legal name, the kind of thing that's easy to get wrong and easy to fix. Someone fixes it. The master updates. It's now right.
The copy doesn't update. Why would it? Nobody remembered it was there.
And nobody notices, because nobody was watching the copy. It just sits there, quietly wrong, drifting a bit further from the truth with every day that passes. The first time anyone finds out is the worst possible time to find out: when the wrong name lands on a legal document with the business's signature under it.
Why nothing screamed
Here's the bit that matters, and it's easy to miss. There was no alarm — and there couldn't have been, given how the thing was built.
A copy going stale isn't an event. It's the absence of one.
We're good at noticing things that happen. An error gets thrown, a build fails, a page goes down — something occurs, and the occurrence is what we hang our monitoring on. But a fact quietly failing to update is a non-occurrence. Nothing happens. The file doesn't change. There's no line in a log, no red flag, no exception, because from the system's point of view everything's fine — the copy is doing exactly what a copy does, which is sit there holding whatever it last held.
You can't monitor your way out of this. You'd have to watch every copied fact, forever, waiting for the master to change and checking whether the copy followed. That's not monitoring. That's a full-time job you'll never staff, watching for a thing that almost never happens — right up until the day it costs you.
The drift law
When I pushed on this, it resolved into a rule I now state as plainly as I can:
The drift law: guarantees live in shape, not in memory.
A rule you have to remember is a rule that'll eventually get forgotten. "Keep the copy in sync with the master" is a guarantee living entirely in vigilance. It needs a person to remember a copy exists, and to update it every single time the master changes, forever. Every one of those conditions is a place for it to fail, and given enough time, at least one of them will.
Vigilance loses not because people are careless, but because vigilance is expensive, boring, and never finished. It costs attention every time, it never gets to be done, and the moment there's pressure or a handover or a new person who never heard the unwritten rule, it quietly stops happening. The guarantee was always going to break. The only open question was when.
The fix is boring, and that's the point
The structural version of this is so unremarkable it barely sounds like a solution.
You don't copy the name. You point at the master record. There's one copy of the fact, and everything that needs the fact references that one copy.
That's it. But look what it does. There's now nothing to keep in sync, because there's one of the thing. The drift we spent this whole piece worrying about can't happen — not because someone's being careful, not because a check is running, but because the structure won't let two versions of the fact exist and disagree. The guarantee has moved out of somebody's memory and into the shape of the data.
Boring is the whole point. The exciting-looking fix — a nightly job that reconciles copies, a dashboard that flags drift, a policy everyone signs — is still vigilance, just dressed up. It still needs the machinery running and the people responding. The boring fix removes the possibility of the problem instead of managing its symptoms. When you can choose between a guarantee that's watched and a guarantee that can't fail, pick the one that can't fail. Every time.
Why AI raises the stakes
You could've told a version of this story twenty years ago. Single source of truth isn't a new idea. So why does it matter more now?
Because of who's reading the copy.
When a human picks up a copied fact that's gone stale, they've got a chance — not a guarantee, but a chance — of noticing it looks off. The name doesn't match what they remember. Something nags. They hesitate, they check, they ask. That hesitation is a safety net you never designed but have quietly relied on your whole career.
An AI agent has no such net. No memory of your intentions, no sense that the name looks wrong, no instinct that something's off. It reads the stale copy, trusts it completely, and acts on it — at speed, at scale, without pausing. The more capable the agent, the more effectively it carries the wrong fact into everything downstream. The structure is now the only thing holding your intent, because the structure is the only thing the agent actually reads.
The question to ask of every fact
You don't need to audit your whole system to start using this. You need one question, applied to every important fact you hold:
Is there one of it, or many?
If there's one, and everything points at it, you're safe by construction. If there are many — the same legal name, the same figure, the same address, copied into a handful of places — then you're not maintaining data. You're maintaining a promise that every one of those copies stays in step with all the others, forever, by people who'll eventually forget. That promise has a use-by date. The only thing you don't know is the date.
So I go looking for the copies and replace them with pointers — not because copying is sloppy (it isn't, it's usually the sensible-looking choice in the moment), but because a pointer moves the guarantee out of memory and into shape. It's slow, unglamorous work, and I'm still finding copies I planted years ago. That's the job.
Pete Gypps — COR Intelligence. Next: the signal law — why "just summarise it" quietly bins the one detail you'll need.
