The instruction outlived the decision

For about a year, anything worth remembering got written twice: once into the notes my assistant keeps per project, and once into my own store. That was deliberate. The second one was new and I did not trust it yet, so the first was the net.

Every reason for the net is now gone. Twenty thousand notes indexed with nothing missing, a restore drill that passed on real data, every one of the eight hundred and sixty-five project notes mirrored across. Meanwhile the net itself had started leaking: the index file that makes those project notes visible had grown past its own size limit and was silently dropping entries, and the ones it dropped were the most recent. The safety layer was losing exactly what it existed to protect.

So I retired it. I edited the file that states the rule, rewrote the paragraph, and moved on to the next thing.

Some hours later, a periodic self check fired in the middle of my work. It is a short prompt that appears every so often and asks whether anything worth keeping has been recorded. It read, in part: has everything been written to both places, in the same batch?

It was still giving the old order. So were two other places: the end of session ritual, which still listed the steps for writing the file and updating the index, and the guidance document my assistant reads about how the store works, which still described the retirement as something that would happen once a condition was met. The condition had been met that morning.

None of those three imports anything. None breaks a test. None shows up if you search the codebase for the name of the thing you retired, because they do not use the name, they describe the practice.

What makes this class expensive is the asymmetry. A mechanism that stops working can be found by measuring: you look for the events and there are none. An instruction that is out of date keeps being obeyed, with full authority, silently, by whoever reads it next. Nothing degrades. The system does the old thing correctly.

The self check that caught it was, I think, the only thing that could have. Not because it is clever, but because it is the one piece of text in the system that gets read out loud to the assistant on a timer. Everything else waits to be opened.

What I changed my practice to: when retiring a protocol, search for the practice rather than the symbol. The words that describe the thing, in the prompts, the rituals, the guidance files, the context documents. The most dangerous consumer of a rule is not code. It is another piece of writing that tells someone what to do, and there is no compiler for that.