Every coding agent reads a file of standing instructions, and across 1,867 repositories those files only go one way: +226% in instruction count over their lifetime, +4.9 net instructions every commit, and the older a line gets the less likely anyone is to remove it. The asymmetry is the whole story. Appending costs one line. Deleting safely costs knowing which failure the line was written for — and once that is gone, the only honest way to check is to try the file without it, and without every combination of the lines around it.
The corpus is every tracked version of the instruction files coding agents read, across 1,867 repositories. A median file holds 39 instructions; the 90th percentile holds 131. Between versions they gain 4.9 net instructions per commit. Drag the commit count and watch the median file run forward, then turn on the one event that ever removes anything.
The rewrite is not a counter-example, it is part of the pattern. 76.8% of all instruction deaths arrive in a single commit that bulldozes the whole file — and afterwards growth resumes slightly faster than before, at 4.9% per commit against 4.1%. Nobody prunes. Occasionally somebody declares bankruptcy, and then the ratchet starts again from a lower number.
Here is why nobody prunes, stated precisely. Instructions interact: two lines can each be redundant on its own and jointly necessary, so testing an instruction in isolation does not tell you whether removing it is safe. If you no longer know which failure the line was written for, the only sound check is to try the file without it — against every combination of the lines that remain. Drag the file size and watch what that costs.
The paper names this catastrophic remembering, and points at the symmetry with the failure mode continual learning is built around. Catastrophic forgetting is a system losing what it knew; this is a system unable to let go of what it no longer needs, for the same underlying reason — the information that would make the decision cheap has decayed, and the decision does not go away.
There is a competing explanation for a growing file: instructions go stale, and staleness takes time, so deletions should cluster on old lines. That predicts a deletion rate that rises with age. Imperfect recall predicts the opposite — the older a line is, the less likely anyone remembers what it was for, so the less likely it is safe to remove. These predictions have different signs, which makes them separable.
The multi-author term is the one that should make you uneasy about your own repository. When more than one person has edited the file, deletion risk decays 0.021 per commit steeper — the more hands a file has passed through, the more certainly its lines are permanent. The author is careful that this proxies for turnover rather than measuring it: it counts editors, not whether the person who wrote a given line has left.
If the missing thing is the reason, write the reason down next to the line — the failure that produced it, the hypothesis, what happened. Then strip the comments out before the prompt reaches the model, so they cost nothing at inference and are addressed purely to the next maintainer. To test whether that works you need a prompt whose correct contents are known, so the paper inverts an instruction-following benchmark: hide the reference instructions, keep the hidden constraints, and have fresh maintainers rebuild the prompt from a brief and noisy feedback.
The placebo arm is what makes this readable. Handing the next maintainer comment-shaped text with no real content lands within 2.7 points of no comments at all, with a confidence interval covering zero — so the effect is the recorded reasoning, not the ritual of annotating. On human-written constraints rather than machine-checkable ones, comments lifted satisfaction from 50.4% to 62.0% over three maintenance rounds, a 23.1% relative gain.
Put your own file in. The growth rate is the measured one — 4.9 net instructions per commit, with no pruning — and the commented projection assumes what the controlled experiment found, that recorded reasoning holds excess near zero. Your file size and commit rate are yours.
Two things to take from the shape rather than the numbers. Every instruction you add is in the context window of every single agent run from now until someone declares bankruptcy on the file — you are paying for it forever. And the moment to write down why you added it is the moment you add it, because that is the only moment the reason is free.