Newer / Older

The Rich Get Richer: How AI is Turning Senior Engineers Up, and Dialing Junior Engineers Down

By Lee Atchison | February 24, 2026 | Artificial Intelligence, Best Practices, Software Development, Tech Trends

AI coding tools promise to transform every developer into a 10x engineer, but new research reveals a more complex reality. While top performers show dramatic productivity gains, the average developer sees only modest improvements. And the surge in AI-generated code is creating an alarming technical debt crisis that threatens long-term system maintainability.

The promise of AI coding tools has been nothing short of astonishing. AI will replace your need to hire software developers, and transform your existing developers into 10x engineers. According to this commonly believed view, AI will revolutionize software development productivity across the board, making the entire world better.

But is this truly a potential reality? A new report from GitClear paints a very different picture. After studying over 2,000 developer-weeks of data, the report shows what I and many others have suspected all along, all is not rosy in the AI coding world.

In fact, the report documents an alarming trend. It turns out that AI coding assistants aren’t democratizing programming skills after all. In fact, they’re widening the gap between your highest performers and the rest of your development team.

The "Steroid Effect"

At first glance, the GitClear report seems almost too good to be true. Developers who heavily used tools like Cursor, GitHub Copilot, and Claude Code showed 4-10x higher output across nearly every metric: commits, durable code changes, pull requests, and test coverage.

Truly, the AI-driven 10x future in software development must be at hand.

But as with most things that seem too good to be true, there was more to the story. Much more. In my view, there are three critical confounding factors that can explain much of this dramatic gap:

Senior engineers adopt AI first. The developers showing the highest AI usage aren't representative of your average team member. They're senior and staff engineers who already touch more of the codebase, prototype aggressively, and push code with less third-party review. These are the people who would be high performers with or without AI. They are heavy tool users, and AI is a strong tool in their growing arsenal.

Startup teams move faster and experiment first. Early-stage companies embrace new tools more aggressively than teams at other companies. These teams lack enterprise constraints on tool adoption, and naturally operate with a "ship fast, test later" mindset. The "AI effect" we are seeing is really just the well-documented "startup effect" in disguise. It’s easy to assume that since startups in general move faster, and startups in general use AI more often, it must therefore be true that AI causes developers to move faster. This isn’t really the case.

Developers building rapidly use AI more. Developers in the middle of high-energy programming times coincide closely with greater AI use. When developers are prototyping new features and making sweeping upgrades, they are relying on AI more. AI isn't necessarily causing the extra output, it's simply accompanying it.

The 25% Reality Check

The researchers tested this theory by comparing developer’s current output to themselves from a year earlier. If AI truly transforms average developers into exceptional ones, we'd expect to see dramatic year-over-year improvement from each developer across the board.

Instead, the average productivity boost was only about 25%. This is a far more modest level than the expected 10x (i.e., 1000%). This is also much closer to other industry estimates, like Sundar Pichai's 10% figure for Google.

Here we can see the uncomfortable truth. AI coding tools are functioning primarily as useful productivity tools for developers who are already high-performant, high-output engineers. They're not transforming the broader developer workforce.

Put more simply, AI tools aren’t making software development skills available to the masses, as the modern media and social media spin seems to indicate. Rather, AI tools are making the top developers better while leaving everyone else behind.

The Architectural Implications

From a software architecture perspective, this creates several challenges that technical leaders need to address:

1. AI WON'T REPLACE YOUR DEVELOPERS

The notion that AI will soon replace human developers is firmly contradicted by this data. What we're seeing is that AI requires sophisticated human guidance to be effective. The developers getting the most value from AI are the ones with deep architectural understanding, strong software engineering fundamentals, and the judgment to know when AI suggestions are helpful versus harmful.

AI coding tools are not autonomous agents capable of replacing developers. They're sophisticated tools that amplify the capabilities of developers who already know what they're doing.

2. THE GROWING SKILLS GAP

More concerning is what this means for team dynamics and career development. If AI primarily benefits those who are already high performers, we're looking at a bifurcation of the developer workforce:

AI-enhanced elite developers who leverage these tools to push even harder, ship more features, write more tests, and move faster than ever before.
Traditional developers who either don't adopt AI tools or don't use them as effectively. They are falling further and further behind their AI-enabled peers.

This isn't just about productivity metrics. It's about career trajectory, compensation, and organizational value. It’s also about organizational sustainability. When knowledge and expertise is concentrated in a few of your top high performant developers, your dependency on these specific individuals to keep the organization going increases. This is a huge risk for long term organizational value. The developers who master AI tooling early will likely command premium positions (with corresponding premium salaries) while those who don't are at risk of becoming increasingly marginalized.

3. THE CODE CHURN CRISIS

But there is another alarming, albeit personally unsurprising, finding in this research.

There is a dramatic increase in code churn among AI power users.

Code churn is defined as code that is written, then almost immediately rewritten or deleted. While these high performant developers showed significantly higher productivity, they generated nearly 10 times more code churn than they did in the previous non-AI world.

Let that sink in: AI-enabled developers generate 10 times more code churn than they did in the previous non-AI world.

From an architectural standpoint, this is deeply troubling. Code churn isn't just wasted effort. Code churn is a leading indicator of technical debt accumulation, architectural inconsistency, and long-term maintenance burden. Churn can originate from various causes, such as scope changes, errors, excess complexity, and hasty additions. When AI accelerates code production without equivalent improvement in code quality and thoughtfulness, we're setting up codebases for future failure.

Let Humans Be Human, Let AI Be AI

It requires an unprecedented level of engineering discipline to evolve AI code suggestions from being simply functional, to being functional, tested, maintainable, and architecturally consistent.

This is why I’ve been advocating a less drastic approach to integrating AI into our software development processes. Rather than replacing developers with AI coding agents, I believe we should:

Make AI tools available to all developers.
Encourage developers to use AI as a form of “peer programmer”. That is, use the tool alongside their normal personal development process as an asset.
Let AI be good at what AI is good at. Correcting syntax mistakes, looking up API references, suggesting best practices for coding simple procedures, and reviewing code for correctness and adherence to security and other policy requirements.
Let human developers be good at what humans are good at. Namely, creating architecturally solid solutions, building systems, using judgment when making decisions.

AI should never, ever be set out on its own to write code. It should always be used with the direct and immediate supervision of a human who is ultimately responsible for what is being created.

Let me be abundantly clear in my view:

AI coding on its own: never.

AI assisting human developers: always.

Additionally, when AI makes a coding suggestion, the code should be examined not only to make sure that it functions as expected, but that it meets appropriate quality guidelines and architectural expectations. Reviews for AI-generated code must specifically check for:

Code duplication and DRY violations that AI tools commonly introduce
Architectural consistency with existing patterns and standards
Unnecessary complexity from overly generic or verbose AI suggestions
Test quality beyond mere coverage numbers

What the Churn?

Leaders should track code churn rates and establish baselines for acceptable levels. While this has always been true, it is even more imperative in an AI-centric world. When developers exceed acceptable churn thresholds, it should trigger architectural review and pair programming sessions to understand the underlying causes.

However, remember that churn in and of itself is not all bad. It can even be healthy, especially during prototyping. Throwing away code in favor of a better way of doing the same thing is a high performant developer’s best practice. Yet, left unchecked, churn can and will lead to technical debt and other quality issues. So, the goal should not be to punish high churn. Rather, the goal should be to create visibility and accountability around the true cost of rapid AI-assisted development.

The Strategic Decision

Organizations face a choice about how to respond to this AI productivity paradox:

Option A: Let the gap widen. Allow your top performers to race ahead with AI tools while the rest of the team continues with traditional approaches. This maximizes short-term output from your best people but risks creating an unsustainable two-tier organization where knowledge and capability become increasingly concentrated in a small group of AI-enhanced developers. Your organization becomes unbalanced.

Option B: Manage the transition deliberately. Invest in bringing your entire team along the AI adoption curve while implementing the architectural safeguards needed to prevent the code churn crisis from undermining long-term maintainability. This requires more upfront investment but creates a more resilient and sustainable organization.

From an architectural perspective, Option B is clearly superior. Software systems are long-lived, and the decisions we make today about code quality and architectural consistency compound over time. Trading long-term maintainability for short-term productivity gains is a devil's bargain that every experienced architect has learned to avoid.

Image created by ChatGPT