Autonomous coding agents now contribute large volumes of merged code to real repositories, and a 2026 empirical study (Sawada et al., EASE 2026) gave one of the first direct file-level comparisons of the maintenance required by AI-generated versus human-authored code: over the first six months after creation, in 100 popular GitHub repositories, AI-generated files received less frequent and smaller maintenance, their modifications were dominated by feature extensions rather than bug fixes, and human developers performed about 83% of that maintenance. The study itself, a concurrent systematic review, and adjacent large-scale results leave the central empirical question open beyond that bounded window. This problem asks for a validated, confound-controlled quantification of the maintenance burden of agent-generated code relative to human-authored code over substantially longer file lifetimes - its extent, its trajectory (does the gap persist, converge, or invert as files age?), its modification-type composition, and the human-versus-agent share - together with an interpretation that discriminates genuine code stability from developer avoidance, non-use in production, and authorship-identification bias. The answer directly informs technical-debt planning, review-effort allocation, and quality-assurance policy for agentic coding.

Background

Software maintenance - the ongoing activities of fixing defects, adapting code to new requirements, and restructuring it - has long consumed the majority of lifecycle cost in software projects, with classic estimates attributing on the order of 90% of lifecycle effort to it. Since late 2024 a new source of code has entered this equation: autonomous coding agents (agentic coding tools), AI systems such as GitHub Copilot's coding agent, Claude Code, Cursor, Devin, and OpenAI Codex, which decompose high-level instructions into subtasks and submit code changes - typically as pull requests (proposals to merge changes into a shared repository) - with little human intervention. These agents now contribute a substantial volume of merged code to real repositories, so whether that code is cheap or expensive to live with has become a software-evolution question with direct cost consequences. Generation-time studies already indicate quality deficits: AI-generated code exhibits more code smells (localized symptoms of poor maintainability, such as duplicated logic), more security vulnerabilities, and higher complexity than human-written code, and a difference-in-differences study of repositories adopting the Cursor agent (a quasi-experimental design comparing adopters to matched non-adopters before and after adoption) found a transient velocity gain but a persistent rise in static-analysis warnings (automated checks flagging suspect constructs) and code complexity that foreshadowed a long-term velocity slowdown. Such results, however, concern code at or shortly after creation. What happens after AI-generated files are merged - how often they are touched, how large the changes are, what kinds of changes they need, and who performs them - determines the actual maintenance burden, and until 2026 this had barely been measured.

An empirical study by Sawada et al. accepted at EASE 2026 was among the first to measure it. Using the AIDev dataset - a public collection of over 456,000 pull requests created by five autonomous coding agents across roughly 61,000 GitHub repositories - the authors identified 508 files created by four agents (Copilot, Claude Code, Cursor, Devin) in 100 popular repositories, sampled up to ten matched human-created files per repository from the same period, and tracked approximately 3,200 subsequent commits for the first six months after each file's creation, classifying each maintenance commit by type (using a commit-classification scheme with categories such as feature addition, bug fix, refactoring, and documentation). They found that AI-generated files receive less frequent and smaller maintenance than human files, that modifications to them are dominated by feature extensions rather than bug fixes (in contrast to human files), and that human developers perform about 83% of this maintenance. The authors themselves flag the bounded scope: a six-month window during the early-adopter period, 100 repositories, four agents, and identification of AI files only through declared agent bot accounts, while developers' undeclared AI-assisted code remains indistinguishable within the human cohort. Their future-direction discussion poses precisely what remains open: whether the maintenance gap persists, converges, or inverts over longer horizons; how patterns differ across agents; and whether low observed maintenance really indicates stability rather than avoidance or non-use. A January 2026 systematic literature review of 87 studies on LLM impact on software maintainability and evolvability reached the same verdict from the other side: the evidence is fragmented and task-specific, and longitudinal designs that directly measure maintenance outcomes are missing.

Adjacent large-scale results sharpen rather than settle the question. A survival analysis (tracking time-to-event data, here time to code modification) of 201 open-source projects covering over 200,000 code units found agent-authored code is modified less and survives longer (a 16% lower hazard - instantaneous event rate - of modification), with per-agent variation exceeding the agent-human gap. A study of 302.6k verified AI-authored commits across 6,299 repositories found that 22.7% of the static-analysis issues introduced by AI assistants still persist at the latest repository revision, indicating durable debt. An industry study of AI-generated C++ in production at a hyperscale enterprise found elevated interface and coupling burdens, higher review effort, and a 5-8% increase in compute consumption. Meanwhile, a validated multi-method census of AI-coding-agent traces across 180 million repositories showed that bot-account detection - the identification method used in the primary study - recovers only about 3% of the agent commits that multi-method detection finds, and that pull-request-based datasets and commit-based detection see largely disjoint agent populations. Any sound answer must therefore measure maintenance over extended horizons and validate its method for identifying which code is AI-generated.

Against this backdrop, the unresolved target is: quantify and interpret the maintenance burden of AI-agent-generated code relative to human-authored code in real repositories over file lifetimes substantially beyond the six months already studied.

Problem Statement

Determine, in real software repositories, the maintenance burden of code created by autonomous coding agents relative to matched human-authored code over file lifetimes substantially beyond the six-month post-creation window already studied (Sawada et al., 2026) - a horizon now increasingly feasible, since agentic coding tools have been accumulating multi-year histories since late 2024, although long-horizon cohorts remain right-truncated and the attainable window is set by the data that have accrued. The objective has four linked dimensions. (1) Extent: the frequency (e.g., commits or change events per unit time) and magnitude (change size normalized by file size) of maintenance on AI-generated versus human-authored files as a function of file age. (2) Trajectory: whether the currently observed lower maintenance of AI-generated files persists, converges to, or exceeds the human-authored baseline as files age. (3) Composition and responsibility: the distribution of maintenance activity across modification types (corrective changes that repair faults, adaptive changes that adjust code to new requirements or environments, and perfective changes that improve structure or performance without altering external behavior, under a stated classification scheme that is mapped to the commit-type scheme used in the six-month baseline so that results remain comparable with it) and the share performed by human developers versus AI agents. (4) Interpretation: whether observed lower maintenance reflects genuine stability of the generated code, or artifacts - developer avoidance of code they did not write, files not exercised in production, or identification bias from undeclared AI assistance in the human cohort and from detection methods that capture only part of agent activity. An answer must be comparative across authorship cohorts, must state and validate its method for identifying AI-generated code, must control for the principal confounds (file importance, functional complexity, repository and adopter characteristics), must handle explicitly the censoring implied by differing file ages and observation windows, and should report results across more than one agent system where data permit. Dimensions (1)-(3) are jointly part of the objective, and dimension (4) is pursued as a bounded assessment that establishes the direction or plausible magnitude of each confound rather than a full separation of it.

References

  1. Sawada, S., Shirai, T., Kashiwa, Y., Yamaguchi, K., Iwata, H., Iida, H. (2026). To What Extent Does Agent-generated Code Require Maintenance? An Empirical Study. arXiv:2605.06464 (accepted at the 30th International Conference on Evaluation and Assessment in Software Engineering, EASE 2026), https://arxiv.org/abs/2605.06464
  2. Matias, B. C., Freire, S., Freitas, J., Fronchetti, F., Damevski, K., Spinola, R. (2026). A Survey on Large Language Model Impact on Software Evolvability and Maintainability: the Good, the Bad, the Ugly, and the Remedy. arXiv:2601.20879, https://arxiv.org/abs/2601.20879
  3. Rahman, M., Shihab, E. (2026). Will It Survive? Deciphering the Fate of AI-Generated Code in Open Source. arXiv:2601.16809, https://arxiv.org/abs/2601.16809
  4. Liu, Y., Widyasari, R., Zhao, Y., Irsan, I. C., Chen, J., Lo, D. (2026). Debt Behind the AI Boom: A Large-Scale Empirical Study of AI-Generated Code in the Wild. arXiv:2603.28592, https://arxiv.org/abs/2603.28592
  5. Tran, M., Lewis, F., Yang, K., Thakur, S., Kini, A., Patil, A., Hashemi, M., Ranganathan, P. (2026). Characterizing the Quality Profile of AI-Generated C++ in Production. arXiv:2608.06640, https://arxiv.org/abs/2608.06640
  6. Khosravani, A., Mockus, A. (2026). Detecting AI Coding Agents in Open Source: A Validated Multi-Method Census of 180 Million Repositories. arXiv:2606.24429, https://arxiv.org/abs/2606.24429
  7. Cynthia, S. T., Al Muttakin, Roy, B. (2026). Beyond Bug Fixes: An Empirical Investigation of Post-Merge Code Quality Issues in Agent-Generated Pull Requests. arXiv:2601.20109, https://arxiv.org/abs/2601.20109
  8. Ferdous, K. M., Banik, D., Chowdhury, K., Shamim, S. I. (2026). Safer Builders, Risky Maintainers: A Comparative Study of Breaking Changes in Human vs Agentic PRs. arXiv:2603.27524, https://arxiv.org/abs/2603.27524
  9. Dipongkor, A. K., Baral, T., Lam, W., Moran, K. (2026). Test Coverage Analysis of Agentic Pull Requests. arXiv:2607.18057, https://arxiv.org/abs/2607.18057
  10. Liang, J. T., Bairathi, M., Chi, W., Talwalkar, A., Subramani, N., Chen, V. (2026). Learning from 53.6K Real-World Developer Edits of AI-Generated Code. arXiv:2607.25130, https://arxiv.org/abs/2607.25130
  11. Li, H., Zhang, H., Hassan, A. E. (2025). The Rise of AI Teammates in Software Engineering (SE) 3.0: How Autonomous Coding Agents Are Reshaping Software Engineering. arXiv:2507.15003, https://arxiv.org/abs/2507.15003
  12. He, H., Miller, C., Agarwal, S., Kastner, C., Vasilescu, B. (2025). Speed at the Cost of Quality: How Cursor AI Increases Short-Term Velocity and Long-Term Complexity in Open-Source Projects. arXiv:2511.04427, https://arxiv.org/abs/2511.04427