This is your last article that you can read this month before you need to register a free LeadDev.com account.
Estimated reading time: 4 minutes
Key takeaways:
AI coding is bloating codebases. Duplication is up 81%, reuse down 70%.- AI hides errors rather thanfixing them: code that catches errors without evaluating their cause is up 47%, producing shallow apps with confusing user behavior. Legacy code is being left to rot. Legacy refactoring has fallen 74% since 2023, and developers are building new rather than tending what exists.
If you’re a developer in 2026, you’re most likely using large language models (LLMs) in your flow. While agentic coding tools can work wonders, their output often flies in the face of do not repeat yourself (DRY), a core software development principle stating that every piece of knowledge must have a single, unambiguous, authoritative representation within a system. GitClear and GitKraken research analyzed 623 million real-world code changes from 2023 to 2026, and discovered some sobering data on the shape of code commits “before” and “after” the AI takeover.
The study found AI-assisted commits make up one quarter of all commits, alongside rising technical debt across eight maintainability-related code quality metrics.
The clearest signal? Code reuse is down significantly from pre-AI levels, marking a shift away from shared libraries.
“Every time you want something, AI creates a new package for it,” says Bill Harding, CEO of GitClear and author of the report. “That general approach to building has all sorts of consequences.”
Your inbox, upgraded. #
Receive weekly engineering insights to level up your leadership approach.
Code duplication is in #
Compared to pre-AI times, code duplication is up 81%. In this study, duplication was tracked as occurrences of five or more consecutive repeated meaningful lines.
“In the long term it starts to get painful when you realize you have five different implementations of the same thing that are similar yet different,” says Harding.
Code reuse is out #
Move (refactor) – a measurement of how often commits edit existing codebases – is down 70%, indicating declining code reuse.
Beyond bloating codebases, this can force teams to rework testing, documentation, and code understandability around new builds.
“If you don’t share code, every time you implement it you’re discarding all the prior progress the developers have made in the repository,” adds Harding.
Old code gets dustier #
Developers are maintaining and incorporating past systems less often. The degree of commits related to long-term updates has exponentially dropped since 2024.
GitClear calls this “legacy refactoring;” changes that remove or update code last touched more than 12 months ago. Since 2023, it has fallen 74%.
Pre-existing code is also getting reworked into new development less and less. Functional connectivity – a measure of how many times calls to other functions are programmed into new commits – has fallen by 35%.
More like this #
AI is hiding errors #
AI’s goal is to satisfy a prompt, but implementing a function properly means inferring which inputs might be passed in, which takes time and tokens.
The shortcut? Write code that never throws an error, no matter how unlikely the inputs.
“That shortcut becomes tech debt for the maintainers, who eventually need to ascertain which error handling was added for cause, versus those added for AI expediency,” explains Harding.
GitClear found 47% more of this error masking in 2026 relative to the base year. It calls this obfuscation: the density of rescue/catch blocks, safe-navigation operators, and stubbed methods that squelch unexpected-input signals.
“AI strongly prefers to write code that won’t be labeled as a defect,” adds Harding. The result is code that silently catches errors without evaluating their underlying cause.
Obfuscation has increased year over year. The end manifestation of error suppression? Shallow apps with fewer deep connections, and confusing user behavior, says Harding.
Are metrics plateauing? #
In early 2025, GitClear research validated the rise in AI-generated code bloat and technical debt. Later, in early 2026, they proved that top performers were making the most of AI all along, subtly reinforcing the old 10x developer myth.
Other studies have traced AI’s impact on coding reliability. Take Google’s yearly DORA report, which in 2024 found that every 25% of additional AI usage creates 7.2% more instability. Its 2025 research and 2026 ROI analysis also pointed to instability tied to AI usage.
All in all, the trends point to looming technical debt problems. Yet, some signals seem to be flattening. “It’s encouraging that the duplication didn’t increase as much and churn only somewhat,” says Harding.
Could this see the final plateau of the downsides of AI-generated code? One can only hope so. For Harding, it’s far from over.
Berlin • November 9 & 10, 2026
AI. Burnout. Big decisions.
The pressure is real. Find what works at LeadDev Berlin.
“What’s less expected is how broad this pattern manifests itself. It’s not just duplication, it’s about not tending to legacy code,” he says.
Bugs in AI-assisted development keep cropping up, from the Moltbook token leak to agents deleting production databases at Replit and PocketOS.
Going forward, leaders should build awareness of AI-coding best practices, review outputs, and measure common obfuscation patterns. Harding also recommends keeping an eye on certain LLMs or junior cohorts that are more prone to producing these faults, and course-correcting.