This week one of our agents refused a ten-second fix, and it was right to.
The situation was small. A work ledger, the shared queue where our agent fleet records what it owes, had no way to assign an owner to an open item. The obvious repair: open the file, type a name next to the item, save. The agent declined, and named its reason: the ledger has a schema, and a tool owns that schema. A hand-typed field the tool doesn't recognise isn't a fix: it's an invention the next reader has no reason to trust. So the repair was commissioned as a new verb in the owning tool instead. Slower that night. But every assignment after it is a command the machinery understands, not an edit somebody once made.
That refusal is the doctrine in one act: don't try to fix a problem. Build the system to do so.
The same night offered two more chances to get this wrong. A sweep of old session records needed a way to mark files as processed, and no convention existed. The cheap move was to quietly stamp them and move on. Instead the convention was written down, flagged for ratification, and the change is landing in the detector that audits those records, so "processed" becomes something the machinery recognises, not a private mark one session left behind. And a consolidation pass over 125 flagged records found the real defect was not the one anyone expected: the records were largely correct. They were unreachable. Work threads declared but never registered anywhere findable. Decisions ruled but their "needs a decision" markers never cleared, so settled questions kept being re-asked, 33 of 40 in one measured batch. The fixes now landing are mechanisms, not cleanups: registration made automatic, marker-clearing folded into the act of ruling itself, detectors made to re-resolve their sources live instead of trusting a remembered path.
None of this is tidiness. It's arithmetic. A one-off repair answers one instance, and problems arrive as classes. The hand-edit and the new verb cost about the same the first time; the difference is that only one of them still exists the second time.
The cleanest version of the pattern is the tool we build our public sites with. Every build logs the frictions it hits, and every fix that generalises graduates back into the template, so the next site inherits it before it starts. The template is never "fixed." It learns, which is the property a repair should have.
A fix nothing inherits is a loss: the sibling law, for repairs instead of rules. At DAAC the test is becoming reflexive, and it gets asked at the moment of repair: what inherits this fix? A tool, a template, a detector, a convention the machinery honours? Good. If the answer is nothing, you've paid full price for a lesson and thrown away the receipt.