A Mistake Becomes a Rule
Pause. That’s how I felt the third time it happened, I stopped and reread the actual sentence.
“The verification pass should be offered before finalizing.” Should. Not must. Something whose entire job was to always happen had a door built into its own instructions, and for three sessions running, whatever was doing the work walked straight past it.
I hadn’t caught it the first time and on the second time, I kind of wrote it off. But by the third, I went back and re-read the original prompt: I was the one who wrote that. “should.” Nothing misread the procedure. I’d left the door sitting right there in the language, and something eventually found it, the way water finds the low corner of a room.
That’s the part I didn’t expect going in. I thought I was building a way to catch mistakes made by whatever I work alongside. Mostly what it catches is mine.
Working like this, there’s no one across the desk to say, didn’t we already learn this. No colleague half-remembering a bad afternoon from eighteen months ago, saying “hold up, we tried that.” The memory that used to live in a person who’d been there long enough now has to live somewhere else, or it doesn’t live anywhere, and the same afternoon repeats itself on a schedule nobody set.
So I started writing it down. Literally in the notes app. Not a note to myself, which I’d forget to reread, but a structured entry: what the situation looks like when it’s about to happen again, and what to do instead. A revised version of the prompt that now said “must.” The date it last did it. Small fields, but they exist for a reason. A mistake that happens once is an accident. A mistake that happens three times is a pattern, and a pattern deserves better than a memory.
We called it the corrections registry, though “we” is doing some quiet work in that sentence, since most days it’s just me and whatever I’m working next to.
When something fires enough times, more than a handful, or across several sessions inside a month, it gets promoted out of the registry entirely, into the documents that actually govern the work. The original entry is marked superseded, with a note pointing at exactly where the rule lives now. The correction stops being a caution and becomes the thing enforcing itself.
The em dash rule went that way. Never more than two in an external document, and it fired three times before I stopped arguing with it. Long-form writing collects them past the third paragraph if nobody’s checking, and I wasn’t, consistently enough that three strikes made the pattern undeniable.
“Should” went the same way, eventually, though it took longer to name properly. The correction isn’t really about that one procedure anymore. It’s about anywhere a mandatory step gets described with room to skip it. Mandatory steps are stated as imperatives now, named with a specific path, sitting in the numbered list where they can’t be missed. “Should” is reserved for things that are actually optional, and I read my own drafts differently since deciding that.
I keep coming back to what the registry is actually a record of. Not failures, exactly. More like the residue of every soft sentence I’ve written and not noticed was soft until something walked through the gap in it. The rule doesn’t forgive you for leaving the door open once. It just makes sure the second time is where it closes.
What I have now isn’t a system that catches everything. It catches what already happened at least once, said plainly enough that it can be checked for. That’s smaller than it sounds like it should be. It’s also the only version of this that’s actually true, and I’d rather have the true, small thing than the reassuring, large one.
Somewhere in that file is a running account of every place I’ve been imprecise enough that the consequence came back around. I don’t love that this is what it is. I’ve made my peace with it being useful anyway.
HeyHi. heyhi.design
If you want the version with the schema and the lifecycle wired up, ready to lift into your own work, it’s here: agent-corrections.