Code maintainability plummets in the AI coding era

Bill Doerrfeld · article · 2026-07-07 source ↗ Reader 🖥️

Changeability & Optionality Code Quality DORA & Engineering Metrics Legacy & Organizational Forgetting Measuring AI Impact Software Design Fundamentals Technical Debt

New longitudinal telemetry (GitClear/GitKraken, 623M commits, 2023-2026) shows that since the AI-coding era began, software maintainability has degraded across eight code-quality metrics -- duplication and error-masking are up while code reuse and legacy refactoring have collapsed -- trading short-term generation speed for compounding technical debt.

practical · expository journalism reporting an empirical study — A short trade-press write-up of GitClear/GitKraken telemetry research, framed as a warning to engineering leaders: it reports findings and ends with prescriptions ('leaders should build awareness of AI-coding best practices, review outputs, measure obfuscation'), so it is practical in aim even though its substance is empirical.

Structure

Part	Role
Key takeaways (bloat / hidden errors / rotting legacy)	Previews the thesis as three concrete failure modes with headline numbers
DRY framing and study introduction (GitClear/GitKraken, 623M changes, AI = 25% of commits)	Names the software principle at stake and establishes the evidence base and its scale
Duplication up and reuse ('Move'/refactor) down	First pillar -- codebases are bloating because knowledge is re-implemented rather than shared
Legacy refactoring collapse and falling functional connectivity	Second pillar -- existing systems are neglected; new code ignores what already exists
Error suppression / obfuscation and the 'satisfy the prompt cheaply' mechanism	Third pillar plus the proposed causal mechanism -- AI writes never-throw code to avoid being flagged as defective
Corroboration (prior GitClear 2025/2026 studies; Google DORA instability findings)	Triangulates the direction of the trend against independent measurement
Plateau question and leader recommendations	Outlook (signals flattening but author expects more decline) and prescription for engineering leaders

Key terms

maintainability
The capacity to keep understanding and changing a codebase over time, operationalised across eight code-quality metrics (duplication, reuse/'Move', legacy refactoring, obfuscation, functional connectivity, churn); the axis of value AI-assisted code systematically underdelivers on.
duplication / copy-paste
Occurrences of five or more consecutive repeated meaningful lines; a DRY violation the author attributes to AI 'creating a new package' for every need rather than reusing existing code.
code reuse ('Move' / refactor)
A metric of how often commits edit existing codebases rather than adding new code; declining reuse means each new implementation discards prior developer progress.
legacy refactoring
GitClear's term for changes that remove or update code last touched more than 12 months ago -- a proxy for whether teams tend existing systems versus only building new.
obfuscation / error masking
The density of rescue/catch blocks, safe-navigation operators, and stubbed methods that squelch unexpected-input signals -- code that silently catches errors without evaluating their underlying cause, added for 'AI expediency' rather than for a real error condition.
DRY (do not repeat yourself)
The principle that every piece of knowledge must have a single, unambiguous, authoritative representation within a system -- the norm AI-generated output is said to violate.
code churn
The volume of recently written code that is soon rewritten or replaced; cited as one of the eight degrading metrics whose recent slowing ('churn only somewhat') hints at a possible plateau.

Propositions

explicitCompared with pre-AI baselines, code duplication -- measured as occurrences of five or more consecutive repeated meaningful lines -- has risen 81%.conf: high
supportsDesigning the AI-native engineering organization · p10 — The measured 81% rise in duplication quantifies that piece's general assertion that AI-assisted code production is increasing duplication and technical debt, requiring reinvestment in standardized approaches.
explicit'Move' (refactor) -- a measure of how often commits edit existing codebases, used as a reuse proxy -- is down 70% versus pre-AI levels, indicating declining code reuse.conf: high
explicitLegacy refactoring -- changes that remove or update code last touched more than 12 months ago -- has fallen 74% since 2023, so developers are building new rather than tending existing systems.conf: high
explicitError-masking obfuscation -- the density of rescue/catch blocks, safe-navigation operators, and stubbed methods that squelch unexpected-input signals -- is up 47% in 2026 relative to the base year.conf: high
explicitFunctional connectivity -- how many calls to other functions are programmed into new commits -- has fallen 35%, meaning pre-existing code is woven into new development less and less.conf: high
explicitcontestedAcross 623 million real-world code changes from 2023-2026, AI-assisted commits now make up roughly one quarter of all commits, and this era coincides with rising technical debt across eight maintainability-related code-quality metrics.conf: high
supportsAgentic Code Review · p4 — Independent GitClear/GitKraken telemetry (623M commits) corroborates Faros AI's separate finding that higher AI adoption drives code churn, defect rate and review duration sharply up -- two independent datasets pointing to the same AI-era maintainability decline.
supportsAI isn't making developers more productive – it's making them busier · p1 — Maintainability decay (duplication, un-refactored legacy) is a concrete mechanism/cost behind the 'busier not more productive' redistribution: the surplus AI output isn't just un-shipped, it is actively degrading the codebase across eight quality metrics, so more code buys less net value.
supportsThe "funhouse mirror": How AI reflects the hidden truths of your software pipeline · p2 — 623M-commit telemetry (duplication +81%, reuse -70%, legacy refactoring -74%, obfuscation +47%) is direct empirical confirmation of the funhouse-mirror claim that AI's coding speed turns a velocity multiplier into a debt accelerator when delivery fundamentals aren't already in place.
contradicts ←We Studied 150 Developers Using AI (Here's What's Actually Changed...) · p3 — Farley's controlled, pre-registered experiment found no significant maintainability difference from AI assistance, directly in tension with this large-scale observational study's finding of rising technical debt across eight maintainability metrics in the AI-commit era — a methodology (controlled small-N vs. observational large-N) tension worth surfacing, not a simple error on either side.
extends ←Measuring AI's Unintended Consequences · p11 — GitClear's telemetry measures rising code churn/duplication under AI empirically across 623M commits; Shore's excess-lines-of-code model turns that same signal (gross code churn) into a forward-looking maintenance-cost projection tool.
explicitcorroboratedIndependent measurement points the same direction: Google's 2024 DORA report found that every additional 25% of AI usage is associated with 7.2% more instability.conf: medium
extends ←AI productivity is burning out your best engineers · p3 — That piece's mechanism -- AI 'externalises comprehension and refactoring cost onto human maintainers' by satisfying the prompt cheaply -- gets a face and a toll here: Reddy identifies who those maintainers are (mid-level engineers bridging model output and real-system needs) and what the externalized cost does to them (burnout and attrition).
supports ←The Acceleration Whiplash · p3 — Faros's independent telemetry (incidents and bugs rising with AI adoption) converges with Google's DORA 2024 finding, cited in GitClear's maintainability study, that every additional 25% of AI usage correlates with 7.2% more instability.
implicitcorroboratedThe maintainability decline is a rational consequence of AI's objective: since its goal is to satisfy a prompt as cheaply as possible, it defaults to spinning up a new package per need and writing code that never throws an error, optimising generation while externalising comprehension and refactoring cost onto human maintainers.conf: medium
supports ←11 Tips For AI Coding With Ralph Wiggum · p9 — A Ralph advocate independently concedes the maintainability-decline mechanism that piece diagnoses: where they attribute decay to AI 'satisfying the prompt cheaply', Tip 8 adds that agents 'amplify what they see' and that a loop 'piling dozens of commits per hour' makes 'entropy compound fast' — practitioner confirmation, from the pro-loop side, that unguardrailed autonomous coding accelerates the measured debt.
explicitSome of the degradation signals are flattening (duplication and churn slowing), hinting at a possible plateau of AI-code downsides, though the study's author expects the decline to continue.conf: low

Arguments

In the AI-coding era, software maintainability is degrading -- codebases are bloating with duplication, suppressing errors, and leaving legacy code to rot -- so short-term AI output speed is being paid for with compounding technical debt. strength: medium

Explicit premises:

Duplication is up 81%, 'Move'/reuse down 70%, legacy refactoring down 74% since 2023, obfuscation up 47%, and functional connectivity down 35%, across 623M commits (2023-2026).
AI-assisted commits are ~25% of all commits during the same period.
Google's DORA finds instability rising with AI usage (7.2% per +25% AI use).
Prior GitClear studies (2025, 2026) already validated AI-generated code bloat and technical debt.

Implicit premises:

Generation is cheap but comprehension and refactoring are where maintainability actually lives, so an AI that optimises for satisfying the prompt optimises the wrong half of the work.
Duplication and never-throw error handling are being traded for speed and for not being flagged as a defect.
The eight measured metrics are valid proxies for the underlying construct 'maintainability', and their co-movement reflects one real decline rather than several unrelated shifts.

Inferences:

Multiple independent maintainability metrics moving adversely in the same period, corroborated by a separate dataset (DORA), indicates a genuine construct-level decline rather than metric noise.
Because the shifts coincide with the rise of AI-assisted commits and match a plausible mechanism (new-package-per-need, never-throw code), AI is the most likely driver of the decline.

Narratives

Bill Harding's package image: 'Every time you want something, AI creates a new package for it,' leaving you with 'five different implementations of the same thing that are similar yet different.'
→ Concretises the abstract duplication metric into a vivid, memorable mechanism a practitioner can picture.
A string of AI-agent disasters -- the Moltbook token leak, agents deleting the production database at Replit, and an agent that deleted a company's entire database at PocketOS 'in 9 seconds, then wrote an apology.'
→ Anecdotal cautionary tales that dramatise the real-world blast radius of declining AI-assisted reliability, beyond the abstract metrics.

Questions addressed

✅ Is AI-assisted coding improving or degrading code maintainability?
Degrading -- eight maintainability metrics moved adversely across 623M commits in the AI era, led by an 81% duplication increase and a 74% collapse in legacy refactoring.
✅ Why does AI produce this pattern rather than clean, reusable code?
Because its objective is to satisfy the prompt cheaply -- spinning up a new package per need and writing code that never throws so it won't be labelled a defect -- which shifts the eventual cost onto human maintainers.
⭕ Is the decline slowing, and could the downsides plateau?
Open: duplication and churn are flattening, which is 'encouraging', but the report's author believes it is 'far from over.'
✅ What should engineering leaders do about it?
Build awareness of AI-coding best practices, review outputs, measure common obfuscation patterns, and watch specific LLMs or junior cohorts more prone to these faults -- but this prescription is asserted, not evidenced.

Gaps

incompleteThe article reports GitClear's headline percentages without the underlying methodology, so a reader cannot assess how each of the eight metrics is computed, whether they are de-biased, or how a commit is classified as 'AI-assisted' -- it is a short trade-press summary standing in for the primary study.
Read next: Read GitClear's full 'AI Code Quality & Maintainability Gap' report and its metric definitions; compare against the earlier 2025 GitClear methodology it builds on.
incompleteEvery headline figure is an era-level or temporal comparison (vs pre-AI, since 2023, relative to the base year) presented alongside AI's rise, not a controlled measurement of AI-authored versus human-authored code. The piece supplies a plausible mechanism but never isolates AI as cause versus confounds -- an influx of juniors, deadline pressure, growing codebase age, or shifting language mix could all move the same metrics.
Read next: Look for studies that segment commits by authorship (AI vs human) and control for team seniority and codebase maturity before attributing the decline to AI.
incompleteGitClear and GitKraken sell tooling into exactly this market, and no non-vendor telemetry is cited to triangulate the specific magnitudes. DORA is invoked for direction (instability rises with AI use) but does not corroborate GitClear's particular numbers, leaving the effect sizes reliant on a single interested source.
Read next: Seek independent, non-vendor telemetry on AI code quality; see the corroborating-but-separate Faros AI dataset (22k developers) and DORA's own instability findings.
incompleteThe mitigations are thin and unevidenced: 'review outputs, measure obfuscation, watch certain LLMs or junior cohorts.' The piece offers no evidence on which guardrails, DRY-enforcement steps, review disciplines, or modularity checks actually reverse the metrics, nor what a maintainability-preserving AI workflow looks like.
Read next: Read practitioner accounts of DRY-enforcing agent reviews and modularity gates (e.g. agentic modularity review that counters copy-paste-over-refactor defaults) to see what concretely bends these curves back.
closed by11 Tips For AI Coding With Ralph Wiggum — That piece flags its mitigations as 'thin and unevidenced' and asks to 'read practitioner accounts of DRY-enforcing agent reviews and modularity gates' that concretely bend the maintainability curves back. This article supplies exactly that workflow: commit-blocking feedback loops (Tip 5), keep-the-codebase-clean-first + explicit quality bar in AGENTS.md (Tip 8), and Tip 11's jscpd Duplication Loop (clones -> shared utilities) and Entropy Loop ('software entropy in reverse'). It only PARTIALLY closes the gap: it gives the candidate maintainability-preserving machinery the gap asks to see, but not the evidence it reverses the metrics — the sole quantified result is a coverage number, not a duplication/reuse measurement (see gap g2).

Closes gaps elsewhere

AI isn't making developers more productive – it's making them busier · g2 — That piece flags that its productivity ladder 'never engages the quality of the extra code' and asks for studies on the maintainability and defect rate of AI-generated code to separate volume from value. This is that study: GitClear's 623M-commit dataset measures the quality of the surplus output directly (duplication +81%, reuse -70%, legacy refactoring -74%, error-masking +47%), showing the 'weak link' is code trustworthiness/maintainability, not only fixed human review capacity.