Scott Robinson sat down to build a feature. The logic for checking user access appeared in a route handler, then a background job, an API endpoint and a webhook. Each time he turned to an LLM. Each time it delivered working code. He merged it.
The conditionals looked nearly identical. Four checks on user status, permissions, suspension and account state, with slight tweaks to variable names. A human writing from scratch would have extracted a helper function. Robinson didn’t. The tests passed. Future changes, he figured, would fall to the model.
He was wrong. In a post published today on Unstack, Robinson describes how that decision trained the LLM on his own laziness. “Every shortcut you merge into your codebase is a signal about how things are done here,” he wrote. The next prompt didn’t start fresh. It copied the pattern already present. Five duplicates became the new normal. A later refactor request preserved all five because that was now the style of the repository.
Robinson’s observation lands at a moment when developers ship AI-generated code at unprecedented speed. Fresh data shows the consequences stacking up faster than many expected. According to an analysis of 623 million code changes from 2023 to 2026 by GitClear and GitKraken, duplication across meaningful lines jumped 81 percent while code reuse fell 70 percent. Legacy refactoring dropped 74 percent. Functional connectivity between modules slid 35 percent. LeadDev reported these figures three days ago in a piece that carries a blunt title: code maintainability plummets in the AI coding era.
Bill Doerrfeld, the author, quotes GitClear CEO Bill Harding: “Every time you want something, AI creates a new package for it.” The result feels efficient in the moment. Over months it produces five slightly different implementations of the same logic. “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,” Harding added.
The pattern matches what Robinson saw in his own project. LLMs read the surrounding code. They absorb its habits. Feed them duplicated conditionals and they will happily generate more. Ask them to clean up later and they often leave the duplicates untouched because the duplicates now define the codebase’s voice.
Earlier evidence pointed the same direction. GitClear’s review of 153 million lines of code through 2023 found a significant rise in churn — lines reverted or edited within two weeks — alongside a drop in code reuse. AI-assisted contributions began to resemble the work of short-term contractors rather than senior engineers who refactor as they go. The 2024 projection showed churn doubling from 2021 levels. GitClear concluded that managers would need deliberate strategies to counteract the downward pressure.
Yet not every study delivers the same verdict. Some research finds no statistically significant difference in maintainability between AI-assisted and human-only code. A LinkedIn analysis of one such effort noted that habitual AI users actually saw slight improvements in a Code Health metric during maintenance phases. Skilled developers who treat the model as a collaborator rather than an oracle appear to fare better. The gap, it seems, comes down to discipline after the code appears.
Other experiments test what happens when guardrails sit between the model and the merge button. Researchers at the Software Improvement Group ran Claude Sonnet 4.6 through the same project-management build twenty times. Ten runs used real-time Sigrid Guardrails in the loop. Ten did not. The guarded runs cut high-risk security findings by 97 percent and lifted maintainability scores by 24 percent. Every guarded result beat every unguarded one. “AI doesn’t necessarily make your code better; it amplifies what’s already there,” said Werner Heijstek of SIG in the company’s blog post published last week. “Having guardrails in place is so important.”
The lesson echoes Robinson’s central point. Treat the LLM as a sponge. It soaks up whatever you give it. Merge sloppy patterns and the sponge grows sloppy. Review, refactor and extract helpers before merging and the model learns those habits instead.
Codacy’s engineering blog reached a similar conclusion earlier this year. Without proper review, AI code tends toward overly long methods that bundle multiple responsibilities. It duplicates logic because the model lacks full context of the existing codebase. The advice sounds familiar: review, refactor and structure the output exactly as you would human contributions. Codacy listed the risks plainly — more code smells, potential security holes, harder maintenance.
Teams that ignore these signals pay later. A Medium post on code quality foundations for AI-assisted codebases noted that 84 percent of developers used AI tools daily by early 2026, yet 45 percent of that code introduced security vulnerabilities in production. The classic red-green-refactor cycle breaks when the pair programmer can generate ten thousand lines before lunch. Treating raw output as ready to merge has already caused incidents at major firms.
So what does disciplined practice look like in practice? Start with the access-check example Robinson shared. Instead of four nearly identical conditionals, create one function — perhaps canReadResource(user, account) — and call it from every location. When the LLM suggests the long conditional, replace it. The next prompt will see the helper and favor it. The signal changes.
Apply the same thinking to error handling. AI often wraps exceptions in catch blocks that swallow problems without diagnosis, producing the 47 percent rise in obfuscation that LeadDev documented. Force the model to log context, rethrow where appropriate or surface clear messages. Do this consistently and the pattern shifts.
Write comments that explain why a decision exists, not what the code does. LLMs generate plenty of the latter. The former guides both future humans and future model calls. Tag AI-generated sections with a short note and the date. Six months later the note reminds everyone — including the LLM — that this block arrived via prompt and may need extra scrutiny.
Measure what matters. Track duplication metrics, churn rates and cyclomatic complexity in every pull request. Tools already surface these numbers. Make them non-negotiable gates. The SIG experiment proved that deterministic checks inside the agent loop outperform post-hoc reviews.
But don’t stop at tooling. Culture still decides outcomes. Robinson admitted he let standards slide because the LLM would handle maintenance. That mindset spreads. One engineer’s duplicated logic becomes the team’s accepted style. Soon the entire repository trains every new prompt on mediocrity.
Conversations on X this week reflect the tension. One developer called the most subtle form of AI psychosis the belief that LLMs produce maintainable code long-term. Another noted longer hours and more production outages after a codebase turned entirely “vibecoded.” A third observed that solid software engineering principles still have no substitute, even if the maintainer is increasingly an AI agent.
The optimistic counterpoint appears in studies of habitual users. When engineers bring strong fundamentals and treat the model as a fast but flawed intern, output quality holds or even improves. They prompt for tests first. They specify architecture constraints. They reject anything that violates DRY, single-responsibility or clear naming. The LLM learns those expectations.
Robinson closed his piece with a simple directive. Write code like a human will maintain it. LLMs are sponges. Make sure what they absorb is good.
That sentence deserves attention because it reframes the entire debate. The question is no longer whether AI can write code. It can. The question is whether teams will accept the responsibility of shaping what the AI learns to write. Ignore that responsibility and the codebase quietly rots under layers of duplicated, hard-to-follow logic. Embrace it and the same tools that accelerate delivery can accelerate quality as well.
The data from 2026 leaves little room for wishful thinking. Duplication rises, reuse falls, legacy work stalls and errors hide in catch blocks. Yet targeted guardrails, consistent refactoring and human oversight produce measurable lifts in maintainability and security. The gap between those two futures is not technological. It is disciplinary.
Engineers who treat every AI suggestion as a draft rather than a deliverable will keep their codebases healthy. Those who merge first and ask questions later will spend the next decade coaxing models to untangle the very patterns they taught them. The choice, as always, sits with the people reviewing the diffs.
WebProNews is an iEntry Publication