The increasing use of AI in software development has led to significant changes in the industry, with 62% of developers now utilizing AI tools. While this has enhanced productivity, it has also resulted in greater code complexity and a decline in code quality. Recent findings from the 2025 GitClear AI Code Quality Research report reveal alarming trends: as AI usage rises, so does the duplication of code, leading to more time spent on refactoring rather than creating new code. This shift indicates a troubling pattern where the ability to manage and simplify complex systems is becoming more critical than simply writing new code. In this discussion, we will explore these challenges and the importance of maintaining high code quality in an AI-driven environment.

The landscape of software development has notably transformed in 2024, with 62% of developers now leveraging AI in their workflows. While this integration has significantly boosted productivity, it has also raised concerns regarding code quality and complexity. The discussion reflects on findings from the recent 2025 GitClear AI Code Quality Research report, which analyzed over 211 million lines of code and revealed a troubling trend: as AI usage increases, so does the complexity of software systems. Developers are now dedicating more time to refactoring existing code rather than creating new features. This shift highlights a critical issue in the industry: as AI generates more code, it often leads to duplication and violates the fundamental principle of not repeating oneself. Consequently, the reliance on AI tools may inadvertently increase maintenance challenges and bug vulnerability, requiring developers to adapt their roles and focus on system-level understanding and refactoring expertise to ensure sustainable software development practices.

Takeaways:

• In 2024, 62% of professional developers are using AI in their development process, significantly impacting productivity.
• The increased use of AI has led to more complex code and larger codebases, affecting overall code quality.
• Developers are now spending more time refactoring existing code rather than writing new features, which alters their workflow.
• The 2025 GitClear report shows a troubling rise in code duplication as AI-generated code becomes more common.
• AI coding tools struggle to understand the full context of projects, leading to increased code duplication and complexity.
• To address these challenges, organizations must focus on long-term maintainability, including reducing duplication and improving test coverage.

Links referenced in this episode:

• softwarearchitectureinsights.com
• 2025 GitClear AI Code Quality Research Report

Hello and welcome to Software Architecture Insights.

Your go to resource for empowering software architects and aspiring professionals with the knowledge and tools they require to navigate the complex landscape of modern software design.

A whopping 62% of professional developers used AI in their development process.

This has done wonders for the productivity of an average software developer and has led many people to assume this means that either we need fewer software developers or more likely, we can get more and better software developed with existing staff.

I wrote on this topic last year in my newsletter.

This report shows that as AI usage has increased from last year, the issues with the developed code in large and complex systems have continued to increase as well.

In short, as AI is used more and more in the software development process, we've seen a corresponding increase in complexity and code size.

The result?

Developers are spending more time refactoring code and less time writing new code.

For the first time in recorded history, the frequency of copy pasted lines exceeded moved lines in code repositories.

More code was copy and pasted, then moved in code repositories.

This represents a fundamental change in how our industry builds software.

Why exactly is this true?

Well, when a developer moves code, they're typically refactoring it, rearranging existing functionality into more reusable modules.

This is the hallmark of good software architecture and something that all but the greenest developers do routinely.

Unfortunately, it's also something that AI software agents almost never do.

You see, code that is copy pasted represents duplication which directly violates the dry or don't repeat yourself principle that has guided professional software development for decades.

The more duplicated code your application contains, the greater its complexity and the more vulnerable it is to bugs and other problems.

The more you use duplicated code, the harder it is for developers to understand the code, the larger the code base and the more susceptible it is to future problems.

Experienced software developers recognize this.

Novice developers and AI coding agents do not.

The numbers are significant.

The rate of code reused has plummeted from 25% to to 10% in just three years.

Meanwhile, code duplication has soared.

Code duplication has seen an Eightfold increase alone.

But why do AI agents generate duplicate code?

The root cause isn't really all that difficult to identify.

Today's AI coding systems excel at generating code quickly, but they operate with significant limitations.

First is limited context.

This means it can't simply see enough of the code base to identify existing functions.

It should reuse or refactor also a path of least resistance.

EI tools are optimized to suggest solutions that work immediately, not solutions that integrate elegantly with existing architecture.

The tab key that inserts suggested code becomes a tempting shortcut that bypasses thoughtful design.

When organizations measure developer productivity by lines of code or commit counts, they inadvertently encourage behavior that prioritizes quantity over maintainability.

Inserting larger quantities of code is actually encouraged rather than discouraged by most developer metric systems.

Even as software developers report greater productivity when using AI tools, software defect rates continue to rise.

This brings us to the evolving role of the professional developer as AI takes over the mechanical aspects of code generation.

Human developers are finding their unique value in areas where AI currently falls short.

System Level Understanding While AI can write discrete functions or even entire components, they lack the capacity to understand the full architectural context of a system.

Humans excel at their ability to identify patterns across disparate parts of the code base and understand the business domain logic it represents.

AI systems do not.

Refactoring Expertise Humans have significant expertise in code refactoring, that is the ability to restructure existing code without changing its external behavior.

Humans are good at consolidating duplicate blocks into reusable functions, creating well named and well documented modules, and establishing canonical implementations that can be reliably tested and maintained.

They also can identify opportunities for reuse that exist across modules and across systems.

Humans can detect and address technical debt.

They are good at finding and fixing problems deeply embedded in systems.

They can examine complex systems and identify patterns that lead to quality issues.

Humans can detect and address technical debt and design comprehensive strategies for improving test coverage.

Finding the Right Balance this isn't to say that AI code assistants aren't incredibly valuable.

They undeniably accelerate the overall development process.

The key is finding the right balance that leverages AI strengths while mitigating its weaknesses.

In order to thrive in this AI centric AI enabled developer world, modern organizations must first adjust metrics.

They must move away from measuring productivity by lines of code or raw commit counts.

Instead, organizations should track metrics that approximate long term maintainability costs, such as duplication rates, test coverage, and defect frequency.

2.

They have to allocate time for refactoring, Build dedicated time into sprints for consolidating duplicated code and improving system and application architecture Managing technical debt and decreasing complexity will become more important as more and more AI generated software is included into our systems and finally, value system knowledge.

Recognize that understanding the entire system and its architectural patterns is increasingly the most valuable skill a developer can bring to your environment.

Experienced engineers have vast system knowledge that is invaluable to organizations in managing their code base.

The Future of Development we're entering a new era where the most valuable developers aren't those who write the most code, but those who excel at organizing, refactoring, and simplifying complex systems.

It is imperative that the measures we use to track developer productivity be adjusted to address this change, or we will continue down the path of more complex and more risky application code.

We risk getting into a situation where we can no longer manage the complexity of all of the code we have asked AI to create for us.

Yes, in the future, AI tools will be built that will help address these limitations, but for now, the human ability to refactor, simplify and consolidate remains critical.

And as it turns out, even more critical than our ability to even write new and original code.

Turns out, the developer experience is worth its weight in gold or even more valuable, its weight in GPE cores.

Thank you for joining us on Software Architecture Insights.

If you found this episode interesting, please tell your friends and colleagues you can listen to Software Architecture Insights on all of the major podcast platforms.

And if you want more from me, take a look at some of my many articles@softwarearchitectureinsights.com and while you're there, join the 2,000 people who have subscribed to my newsletter so you always get my latest content as soon as it is available.

Thank you for listening to Software Architecture Insights.