AIエージェントが書いたコードはマージ後どうなるか？その追跡調査Do These Violent Delights Have Violent Ends? Measuring the Post-Merge Fate of Agentic Code

As AI coding agents move from experimental demos into everyday development workflows, a pressing question is emerging: what actually happens to the code these systems write once it is merged into a real codebase? A new empirical study posted to arXiv attempts to answer that by tracking the post-merge lifecycle of agent-generated code, measuring its long-term quality, the amount of churn it attracts, and the maintenance burden it imposes relative to code written by human developers. The results matter because organizations are increasingly delegating substantial portions of routine engineering work to autonomous or semi-autonomous agents, often without a clear picture of the downstream costs.

The core contribution of the paper is longitudinal rather than snapshot-based. Much of the existing evaluation of AI-generated code focuses on the moment of creation: whether a suggestion compiles, passes unit tests, or resolves a benchmark task such as those in SWE-bench. Those metrics say little about what happens weeks or months later. By following merged contributions over time, the authors appear to be probing a different and arguably more consequential dimension of software quality, namely whether agent-authored code tends to be revised, reverted, or rewritten more often than human-authored code, and whether it accumulates defects or technical debt at a different rate.

Churn is a central metric in this kind of analysis. In software engineering research, code churn typically refers to how frequently lines are modified, added, or deleted after they first land. High churn shortly after a merge can indicate that the original change was incomplete, poorly understood, or misaligned with the surrounding system. If agent-generated code shows elevated churn, that would suggest the apparent productivity gains at authoring time are partly offset by later rework. Conversely, comparable or lower churn would strengthen the case that agents can produce durable contributions. The paper reportedly quantifies these differences, which is valuable precisely because it grounds the discussion in observed behavior rather than intuition.

Studies of this type face notable methodological challenges, and readers should weigh the findings with those in mind. Reliably attributing a commit to an AI agent versus a human is difficult, since agent output is frequently edited by a person before submission, and many teams do not label such contributions explicitly. Confounding factors also complicate causal claims: agents may be assigned systematically easier or harder tasks, may operate in specific parts of a codebase, or may be used disproportionately by less experienced developers. Any measured difference in maintenance burden could therefore reflect task selection or team practices as much as the intrinsic properties of the generated code. The extent to which the authors control for these variables will determine how far the conclusions generalize.

The work sits within a fast-moving industry context. Tools such as GitHub Copilot, Cursor, and a growing set of agentic systems including Claude Code, OpenAI's Codex-style agents, Devin, and various open-source frameworks are now capable of opening pull requests, running tests, and iterating with limited human oversight. Vendors have emphasized speed and task completion rates, while comparatively less attention has gone to long-term maintainability. Empirical tracking studies like this one help fill that gap, complementing benchmark-driven evaluation with evidence drawn from how code behaves in production repositories over its actual lifespan.

For practitioners, the practical implication is that acceptance at merge time is not a sufficient measure of success. Teams deploying agentic coding systems may want to monitor post-merge signals such as revert frequency, bug-fix commits, and review overhead to understand the true cost of adoption. It also reinforces the continued importance of code review, testing, and ownership practices as safeguards, regardless of who or what produced a given change.

As with any single study, the findings should be treated as informative rather than definitive, and their applicability likely depends on the languages, project types, and agent versions examined. The rapid pace of model improvement means that measurements taken today may not hold for future systems. Even so, by shifting the evaluation lens from generation to consequences, the research offers a useful framework for assessing the real-world risks and benefits of letting AI agents contribute to production software, and it points toward maintainability as a metric that deserves far more scrutiny than it has received.