AI agents are learning to preserve experience in files: repository instructions, reusable skills, warnings, workflows, and exceptions that can be loaded again for the next task. Three new research papers suggest that this useful memory is creating a second problem. The files can grow faster than teams can explain, prune, or verify them.
The issue is not simply that prompts are getting longer. Agent instructions are becoming operational infrastructure. They decide when an agent should act, which tools it may use, what sequence it should follow, and what counts as a finished result. Once those rules accumulate, maintenance becomes a question of provenance and structure as much as token count.
Instruction files develop a ratchet
A paper submitted on August 11 under the title Why Does CLAUDE.md Keep Growing? examines 1,867 public GitHub repositories and 247,694 individual instruction lifetimes. The researchers report that agent-facing instruction files more than tripled over their observed lifetimes, increasing 226 percent in instruction count. Excluding mass rewrites, each commit added a net 4.9 instructions on average.
The authors call the pattern “catastrophic remembering.” A new rule is cheap to append after something fails. Removing it later is risky because the reason for adding it may no longer be recoverable. Their history analysis found that older instructions became less likely to be deleted, while wholesale rewrites accounted for most instruction disappearances. Even then, growth resumed.
The proposed intervention is familiar from traditional software: record why a rule exists. In controlled experiments, informative comments reduced 99.3 percent of excess instructions while preserving task correctness near the tested optimum. On a separate real-world instruction-following test, comments improved performance by as much as 23.1 percent. The paper also cautions that writing a comment is safer than automatically deleting a rule; safety-relevant instructions still need human review.
Compression has to preserve procedure
A second August 11 paper, SkillZip, approaches the same pressure from a different direction. Its authors study self-evolving agents that add successful procedures and fixes to reusable skills. Across their experiments, evolved skills expanded to more than five times their initial length on average, even after genuinely new procedural content began to level off.
Ordinary summarization is a poor fit for this material. A rare exception may occupy only one sentence but protect a critical branch. A name and description may determine whether the skill loads at all. Tool arguments, output fields, and action order can be more important than frequently repeated explanation.
SkillZip therefore treats a skill as a typed contract. It states shared rules once, factors repeated action sequences into common procedures, and keeps differences as explicit exceptions. The reported experiments produced an average compression rate of 31.2 percent while slightly exceeding the uncompressed skills’ average task score. The method used no task rollouts during compression and averaged a 3.5-fold speedup over the paper’s evaluation-guided comparison system. Those results are promising, but they remain research findings across three benchmark families rather than a universal guarantee for production agents.
A maintenance ecosystem is already forming
The third paper, GitSkills, shows the scale of the artifact now being maintained. Its authors collected 3,797,117 files named SKILL.md from 282,200 public GitHub repositories in July 2026. Grouping identical files by content hash produced 1,877,981 distinct contents, meaning 50.5 percent of collected files were verbatim copies.
That reuse is occurring without a central registry or package manager. Skills spread by copying folders between repositories, sometimes with scripts and reference material beside the instruction file. The dataset does not prove those copies are unsafe or stale, and its public-repository coverage is a lower bound. It does expose a new research surface: how updates propagate, how modified copies diverge, and whether executable additions can enter a widely reused skill without consistent review.
TENS analysis: memory needs a maintenance stack
The combined evidence points to three separate maintenance failures that a shorter prompt alone cannot solve. Provenance failure makes teams forget why a rule exists. Representation failure repeats the same rule across branches and examples. Distribution failure allows copied skills to diverge without a dependable update path.
That separation matters because each failure needs a different control. Comments or structured rationale preserve intent. Contract-aware compression consolidates repetition while retaining rare requirements. Hashes, versioning, dependency records, and review history can make reuse traceable. Applying only compression could produce a neat file whose remaining rules are still unexplained or stale.
A practical audit should therefore measure more than length. Teams need to know which requirement introduced each rule, where that rule applies, what evidence would justify changing it, whether another copy exists, and which tests protect the behavior. Context size is the visible cost; lost rationale is the deeper liability.
The broader shift is easy to miss. Agent memory is becoming software, but much of it is maintained as prose. The next generation of reliable agents will need tools that treat instructions as living operational artifacts: reviewable, compressible, versioned, and connected to the evidence that made them necessary.
Featured image: Nzinga Tull works in NASA Goddard’s Hubble control room during a switch to backup spacecraft hardware. Photo: NASA Goddard Space Flight Center / Rebecca Roth via Wikimedia Commons. Public domain, United States government work. Center-cropped from 6,017 × 4,273 pixels to 16:9 and resized to 1,920 × 1,080 pixels; no generative or substantive alteration.
