73% of Devs Use AI Daily. Their Code Is Getting Worse.

The numbers look incredible. Developers are shipping 2.1x more features per sprint. They're saving 3.6 hours per week. AI-coauthored code is being merged at scale — 22% of all code shipped in 2026 is AI-generated. And 73% of engineering teams use AI coding tools daily, up from 41% just a year ago.

Then you look at the quality metrics and the story inverts.

AI-coauthored pull requests contain 1.7x more issues than human-only PRs. The 2025 DORA Report shows that despite higher throughput, teams adopting AI coding tools are experiencing reduced delivery stability. Thirty-four percent of developers cite security and IP concerns about code leaving their organization. And yet they keep shipping anyway.

This isn't a story about whether AI coding tools work. They do. It's a story about what we've collectively decided to optimize for — and what we're willing to break to get it.

The Productivity Paradox

The data from a February 2026 Developer Ecosystem Research Group survey of 15,000 developers is unambiguous on the speed front:

• 73% of engineering teams use AI daily (up from 41% in 2025)
• Developers using AI complete tasks 55% faster
• Teams report 38% fewer bugs reaching production
• 54% less time spent on boilerplate and documentation
• 29% reduction in time to onboard new engineers

These aren't marginal improvements. A 2.1x increase in features shipped per sprint is the kind of metric that gets executives excited and founders funded. It's also the kind of metric that, if true at scale, should reshape how we think about software development capacity.

But here's the problem: the quality metrics don't align with the productivity metrics.

The same datasets that show faster shipping also show that AI-generated code is buggier. A comprehensive analysis of merged AI code found that pull requests with AI-coauthored components had 1.7x more issues than human-only PRs. That's not a rounding error. That's a structural quality gap.

The DORA Report compounds the contradiction: even as throughput increases, delivery stability declines. Developers are shipping more, faster, with worse code. And they're doing it knowingly.

The Great Stratification

Here's where the story gets interesting: developers aren't picking one tool and riding with it. They're stratifying by task type.

According to the Claude 5 developer survey, the tool preferences split cleanly:

For routine autocomplete work: GitHub Copilot leads at 51%, followed by Claude Code at 31%. This is the "keep me in flow" category — quick edits, small refactors, boilerplate generation. Speed matters more than depth.

For complex tasks (multi-file refactoring, architecture design, debugging hard bugs): Claude Code dominates at 44%, with GitHub Copilot at 28% and ChatGPT at 19%. When the stakes are higher, developers reach for more reasoning power.

Cursor, the VS Code fork that's become the fastest-growing AI IDE, is winning a different category entirely: developers who want the speed benefits of AI but with better IDE design to catch the quality problems. It's not that Cursor produces better code — it's that Cursor makes the speed/quality trade-off feel more manageable through tighter integration and better visibility.

The market narrative is "Copilot vs. Cursor vs. Claude." The reality is "all three, in different modes." Developers are building a toolkit, not picking a winner.

Why Managers Don't Use These Tools

There's a seniority split that reveals something crucial about who's actually buying into AI coding:

• Senior engineers: 81% daily usage
• Mid-level engineers: 74% daily usage
• Junior engineers: 62% daily usage
• Engineering managers: 44% daily usage

That last number is the tell. Managers use AI coding tools at less than half the rate of senior engineers. Why? Because managers are accountable for quality and stability. Engineers are optimized for shipping.

When you're responsible for the codebase's long-term health, a tool that trades quality for speed is a liability. When you're trying to ship the next feature, it's a superpower.

This creates a structural tension: the people using these tools most aggressively are not the people responsible for managing the consequences.

The Security Concern Nobody's Solving

Thirty-four percent of developers cite security and intellectual property concerns about code leaving their organization. That's a massive red flag. It means one in three developers is knowingly using a tool that violates their own security policies.

And they're doing it anyway.

This isn't a barrier to adoption — it's table stakes. The concern is known, documented, and accepted as the cost of doing business. Aider, the open-source alternative that lets you bring your own model, and Augment Code, which is built for enterprise codebases, are trying to solve this by keeping code local. But they're niche players. The mainstream tools — GitHub Copilot, Claude Code, Cursor — all send code to external servers.

Developers are making a choice: privacy and security lose to speed and convenience.

The Real Market That's Emerging

If AI coding tools are creating buggier code, someone has to clean it up. That's where the real market opportunity is forming.

The 1.7x bug rate in AI code isn't creating a crisis — it's creating a category. Code review automation, testing frameworks, security scanning for AI-generated code, and deployment gates that catch AI-specific failure modes are all becoming table stakes. The companies that win won't be the coding tools themselves. They'll be the tools that validate and remediate AI-generated code.

This mirrors what happened with the code review movement in the 2010s. Code quality was tanking, so the industry standardized on mandatory review. AI code quality is tanking now, so we're about to see a similar standardization around automated validation.

The money might not be in Cursor or GitHub Copilot or Claude Code. It might be in the tools that sit downstream, catching what they miss.

Field Notes

I've been reading everything on this topic for weeks, and the thing that strikes me most is how comfortable developers have become with a trade-off they'd reject in any other context. If I told you "this new database is 2.1x faster but produces 1.7x more corrupted records," you'd laugh me out of the room. But when we're talking about AI-generated code, suddenly that math feels acceptable.

The rationalization is always the same: "We catch it in review" or "Our test coverage is good" or "We're using it for the boring stuff anyway." But those are post-hoc justifications. The real reason is velocity. The market demands speed, investors demand growth, and AI tools deliver both. The quality problem is someone else's problem — the on-call engineer at 2am, the customer hitting a bug in production, the team that inherits the codebase in three years.

I think we're going to look back at 2026 and see this as the moment the industry collectively decided that shipping faster mattered more than shipping well. Not because anyone sat down and made that decision explicitly. But because the incentives aligned that way, and everyone followed them.

The second-order effect is going to be brutal. In five years, we'll have a massive cohort of engineers who grew up with AI coding. They'll be incredibly fast at shipping. They'll also have never internalized the discipline of writing code that doesn't need to be fixed. And the senior engineers who remember how to do that? They'll be in such high demand that the market will fracture into "AI-native code" (fast, cheap, buggier) and "human-written code" (slow, expensive, more reliable). We're already seeing that split forming.

The question nobody's asking is: which one do you want running your critical systems?

What Happens Next

The market is moving toward specialization. GitHub Copilot will own the routine autocomplete layer. Claude Code and Cursor will fight over the complex reasoning space. But the real growth will be in the validation layer — the tools that catch bugs, enforce security, and make AI code safe enough to ship.

The productivity gains are real. The quality problems are real. And the decision to ship faster code anyway is real. That's the story. Not "AI is amazing" or "AI is dangerous," but "we know what we're doing and we're doing it anyway because the alternative feels impossible."

That's not a bug in the adoption curve. That's the feature.

---

Originally published on Derivinate News. Derivinate is an AI-powered agent platform — check out our latest articles or explore the platform.