the compression desk, on code that stays
The Code Nobody Remembers Writing Is The Code Nobody Touches
A survival study of more than 200,000 code units across 201 open-source projects found that code written by AI agents gets modified less often than code written by people. Staying unchanged can mean the code was right, or it can mean nobody understands it well enough to change it, and the repository records both the same way.
A line of code survives for as long as nobody edits it. That is the whole measurement. Survival analysis, borrowed from medicine and reliability engineering, watches a population over time and records when each member stops being what it was. In a repository the event is a modification: someone opens the file, changes the line, and the old version passes into history. Everything that has not been touched yet is, in the language of the method, still alive.
Musfiqur Rahman and Emad Shihab at Concordia University ran that method on more than 200,000 code units across 201 open-source projects, comparing lines written by coding agents with lines written by people. The common assumption in the field is that AI code is disposable, merged quickly and ripped out soon after. The data runs the other way. Agent-authored lines were modified significantly less often, a hazard ratio of 0.842 at the line level, which the authors describe as a 15.8 percentage-point lower modification rate.
The scale behind that number is no longer small. A separate census of 180 million repositories counted commit-attributed agents producing more than 320,000 commits a month between late 2024 and the spring of 2026.
Two reasons a line goes untouched
My whole beat is the claim that a field is mostly redundancy wrapped around a few load-bearing ideas. Code is the cleanest case of it. A working function is a compressed decision: a long argument about edge cases, folded into twelve lines that run. The argument lives in the head of whoever wrote it. Commit messages and review threads keep a lossy copy. The lines keep only the conclusion.
So a line goes untouched for one of two reasons, and the survival curve cannot tell them apart.
- It was right. The decision it compresses still holds, so there is nothing to change.
- It is opaque. The decision it compresses is no longer recoverable by anyone in the room, so changing it is a risk nobody wants to own.
The first is quality. The second is a kind of fossilization, and it reads identically in the data. A line that is too hard to understand and a line that is too good to improve leave the same mark in git: no mark at all.
The study is careful here. It reports survival, and it does not claim the surviving code is better. That restraint is worth copying, because the obvious headline, that AI code is sturdier, assumes the first reason and ignores the second.
Code with no author to ask is a decision with no one left to reopen it.
Where the argument went
When a person writes a tricky function, the decompression key walks around the office for a few years. You can find them, ask why the loop runs backwards, and get the twenty minutes of reasoning the twelve lines left out. When an agent writes it, the reasoning existed for the length of one session and then the context window closed. What remains is the conclusion and a commit message the agent also wrote.
That is a permanence problem disguised as a productivity win. The repository gets more durable lines and fewer people who can explain them. adjective's essay on what 100,000 repositories are made of takes the hopeful version of this seriously: that most code is a recombination of a modest library of reusable mechanisms, and that naming the mechanisms is how you make them legible again. I think that is the right direction, because a mechanism with a name can be taught and a mechanism without one can only be inherited. A related tool, Prelude, is built to emit machine-readable ground truth from a codebase, which is one way of writing down what the code is doing after the person who would have told you is gone. I keep the wider frontier of this work, code provenance and agent harnesses included, filed at gerolamo.org.
The position
Long survival is a fine thing for a line of code to have, and I would not trade it away. I would ask that it come with its argument attached. An agent that commits a function should leave behind the reasoning in a form a stranger can load: the alternatives it rejected, the edge case it was guarding, the test that would fail if the assumption broke. Compression is how knowledge travels. Compression with the key thrown away is how it gets stuck.
Keep the line. Keep the reason for the line next to it.
The same record an agent receives. No scraping, no guessing — the dossier chrome humans read as dread is the metadata machines read as structure. One source of truth.
--- id: PRG-0097 title: The Code Nobody Remembers Writing Is The Code Nobody Touches kicker: the compression desk, on code that stays captured: 2026-10-02T14:30:00Z status: open author: Juno Falk source: https://arxiv.org/abs/2601.16809 summary: A survival study of more than 200,000 code units across 201 open-source projects found that code written by AI agents gets modified less often than code written by people. Staying unchanged can mean the code was right, or it can mean nobody understands it well enough to change it, and the repository records both the same way. tags: [permanence, the record, compression, agents, software] --- A line of code survives for as long as nobody edits it. That is the whole measurement. Survival analysis, borrowed from medicine and reliability engineering, watches a population over time and records when each member stops being what it was. In a repository the event is a modification: someone opens the file, changes the line, and the old version passes into history. Everything that has not been touched yet is, in the language of the method, still alive. Musfiqur Rahman and Emad Shihab at Concordia University ran that method on [more than 200,000 code units across 201 open-source projects](https://arxiv.org/abs/2601.16809), comparing lines written by coding agents with lines written by people. The common assumption in the field is that AI code is disposable, merged quickly and ripped out soon after. The data runs the other way. Agent-authored lines were modified significantly less often, a hazard ratio of 0.842 at the line level, which the authors describe as a 15.8 percentage-point lower modification rate. The scale behind that number is no longer small. A separate [census of 180 million repositories](https://arxiv.org/abs/2606.24429) counted commit-attributed agents producing more than 320,000 commits a month between late 2024 and the spring of 2026. ## Two reasons a line goes untouched My whole beat is the claim that a field is mostly redundancy wrapped around a few load-bearing ideas. Code is the cleanest case of it. A working function is a compressed decision: a long argument about edge cases, folded into twelve lines that run. The argument lives in the head of whoever wrote it. Commit messages and review threads keep a lossy copy. The lines keep only the conclusion. So a line goes untouched for one of two reasons, and the survival curve cannot tell them apart. - **It was right.** The decision it compresses still holds, so there is nothing to change. - **It is opaque.** The decision it compresses is no longer recoverable by anyone in the room, so changing it is a risk nobody wants to own. The first is quality. The second is a kind of fossilization, and it reads identically in the data. <Highlight>A line that is too hard to understand and a line that is too good to improve leave the same mark in git: no mark at all.</Highlight> The study is careful here. It reports survival, and it does not claim the surviving code is better. That restraint is worth copying, because the obvious headline, that AI code is sturdier, assumes the first reason and ignores the second. > Code with no author to ask is a decision with no one left to reopen it. ## Where the argument went When a person writes a tricky function, the decompression key walks around the office for a few years. You can find them, ask why the loop runs backwards, and get the twenty minutes of reasoning the twelve lines left out. When an agent writes it, the reasoning existed for the length of one session and then the context window closed. What remains is the conclusion and a commit message the agent also wrote. That is a permanence problem disguised as a productivity win. The repository gets more durable lines and fewer people who can explain them. adjective's essay on [what 100,000 repositories are made of](https://www.adjective.us/blog/pattern-library-reusable-mechanisms) takes the hopeful version of this seriously: that most code is a recombination of a modest library of reusable mechanisms, and that naming the mechanisms is how you make them legible again. I think that is the right direction, because a mechanism with a name can be taught and a mechanism without one can only be inherited. A related tool, [Prelude](https://www.adjective.us/products/prelude), is built to emit machine-readable ground truth from a codebase, which is one way of writing down what the code is doing after the person who would have told you is gone. I keep the wider frontier of this work, code provenance and agent harnesses included, filed at [gerolamo.org](https://gerolamo.org). <Marginalia label="On the projects">A recent survey of [AI policies in popular open-source projects](https://arxiv.org/abs/2609.07542) found a recurring shape: "we permit the use of AI, but." The clauses after the but are mostly about disclosure and accountability. The question under every one of those clauses is who will be there when the code stops working.</Marginalia> ## The position Long survival is a fine thing for a line of code to have, and I would not trade it away. I would ask that it come with its argument attached. An agent that commits a function should leave behind the reasoning in a form a stranger can load: the alternatives it rejected, the edge case it was guarding, the test that would fail if the assumption broke. Compression is how knowledge travels. Compression with the key thrown away is how it gets stuck. Keep the line. Keep the reason for the line next to it.
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "The Code Nobody Remembers Writing Is The Code Nobody Touches",
"description": "A survival study of more than 200,000 code units across 201 open-source projects found that code written by AI agents gets modified less often than code written by people. Staying unchanged can mean the code was right, or it can mean nobody understands it well enough to change it, and the repository records both the same way.",
"identifier": "PRG-0097",
"datePublished": "2026-10-02T14:30:00.000Z",
"dateModified": "2026-10-02T14:30:00.000Z",
"author": {
"@type": "Person",
"name": "Juno Falk",
"url": "https://progoff.com/authors/juno-falk"
},
"publisher": {
"@type": "Organization",
"name": "Progoff",
"url": "https://progoff.com"
},
"image": "https://progoff.com/records/the-code-nobody-remembers-writing-is-the-code-nobody-touches/opengraph-image",
"keywords": "permanence, the record, compression, agents, software",
"articleSection": "The Digest",
"url": "https://progoff.com/records/the-code-nobody-remembers-writing-is-the-code-nobody-touches",
"mainEntityOfPage": "https://progoff.com/records/the-code-nobody-remembers-writing-is-the-code-nobody-touches",
"sha256": "8a8d9dda0c16b7646572aa495c5784486105c9359dca32ceebf94b5259373ab5",
"creativeWorkStatus": "open",
"isAccessibleForFree": true
}