AI and Coding: Separating Perception from Reality

When people hear that Google now generates roughly 25% of its code with AI, it’s tempting to imagine that developers are only responsible for the remaining 75%. The picture painted is that AI is doing a quarter of the work, while humans are left to handle the rest.

The reality, however, is far more nuanced.

I use GitHub Copilot on a daily basis. At times, it seems to read my mind, autocompleting the exact snippet I was about to type. In those moments, it feels like a true productivity boost. If someone measured raw output, AI might appear to be “writing” half my code. But here’s the catch: I’m still the one driving, thinking, and structuring the logic. The AI isn’t designing solutions — it’s just typing faster on my behalf.

In other words: AI doesn’t write the code. It types it out.

Where AI Helps the Most

AI shines when asked to handle repetitive or boilerplate code. Need a class, middleware, component, or route scaffolded quickly? An AI assistant can draft it instantly. Tools like Cursor and Windsurf — specialized forks of VSCode — are even designed around this prompt-first style of coding.

This can save time, but it’s never hands-off. AI-generated blocks often require significant revision before they’re ready for production. The review and refactor process is just as important as before, if not more so. Developers remain fully accountable for ensuring that code works, integrates seamlessly, and follows best practices.

So, while technically AI might be producing a large percentage of the raw code, it’s doing so under human supervision. The “heavy lifting” of thinking, structuring, and refining still sits squarely with the developer.

The Illusion of Productivity

Here’s a key point many overlook: AI often generates more code than necessary.

When asked to solve a problem, AI doesn’t weigh whether that code should exist at all. It simply fulfills the request. This leads to bloated output and inflated statistics about “AI-written code.”

For example, I once used AI to integrate a Rive animation with hover effects. I asked it to set up event handlers for mouse hover, assuming that would be required. The AI dutifully wrote the logic and embedded it into my page. The hover worked, but console errors started appearing.

Why? Because Rive already had hover functionality baked into its state machine. The extra handlers were redundant.

AI didn’t flag my mistake. It didn’t know better. It just produced what I asked for — even though it wasn’t needed.

The outcome: more lines of code, but not more value.

The Rise of Copy-Paste Bloat

This trend isn’t just anecdotal. Platforms like GitClear have analyzed AI-generated code at scale and found a troubling pattern:

• Copy-paste duplication is rising.
• Code reuse and refactoring are declining.

In essence, AI increases the raw number of lines but at the expense of maintainability. Codebases risk drifting away from DRY (Don’t Repeat Yourself) principles, becoming harder to manage in the long run.

So yes, AI-written percentages are going up — but partly because unnecessary or redundant code is being added. That’s not efficiency. That’s bloat.

A Reality Check: Developers Have Always Reused Code

Here’s a little secret for non-developers: even before AI, programmers rarely wrote every line from scratch.

• Stack Overflow has long provided crowdsourced snippets for solving common issues.
• Codepen and Shadertoy have showcased reusable examples for front-end design and WebGL shaders.
• Tools like Yeoman and Vite helped scaffold entire projects in minutes.
• And frameworks themselves (React, Angular, Django, Rails) exist precisely to prevent rewriting boilerplate code.

In other words, software development has always been about assembling and adapting existing solutions. AI is simply the next step in this progression.

And just as some junior developers once pasted Stack Overflow answers without understanding them, today’s newcomers can misuse AI code blindly, leading to bugs and inefficiencies. The tool doesn’t eliminate the need for expertise; it just shifts where expertise is applied.

Developers as Architects, Not Typists

Writing software has never been about raw typing speed. The real skill lies in:

• Designing architecture.
• Balancing performance and scalability.
• Ensuring security.
• Maintaining clean abstractions.
• Coordinating across a team.

AI can provide snippets and suggestions, but it cannot curate, judge, or innovate. It cannot decide whether a solution is the right one for the broader system. That’s the developer’s role — and it will remain indispensable.

Think of it this way: developers are storytellers; code is just the language. AI might provide words and phrases, but the story still comes from the human mind.

The Danger of Misinterpreting Metrics

Here’s where organizations risk going astray.

The hype around AI has created enormous pressure for companies to look like they’re ahead of the curve. Announcing that “30% of our code is AI-generated” sounds impressive. But it’s the wrong metric to optimize for.

If leaders set mandates like “we want 50% of our code written by AI next year,” they’re chasing the wrong outcome. What matters isn’t how much AI writes — it’s whether the final product is efficient, reliable, and maintainable.

Ironically, forcing teams to overuse AI could reduce efficiency by bloating codebases and introducing unnecessary complexity.

The smarter move? Encourage exploration. Don’t mandate usage. Let developers integrate AI naturally into their workflows, finding where it adds real value.

Skills That Will Matter More in an AI-Driven World

AI-enabled coding isn’t going anywhere. It will only become more powerful and more common. That doesn’t mean developer skills are becoming irrelevant — it means the relative importance of skills is shifting.

For instance:

• Memorizing syntax is less critical when AI can autocomplete everything.
• But system architecture, security expertise, debugging, and communication are becoming even more valuable.
• The ability to prompt effectively — to guide AI into generating useful code — is itself becoming a new meta-skill.

Developers who adapt and evolve with these tools will thrive. Those who resist entirely may fall behind, while those who embrace AI blindly risk producing messy, fragile software. The winners will be those who strike the balance.

The Middle Ground

The worst mistake is to swing to extremes.

• AI won’t replace developers entirely. It lacks originality, judgment, and accountability.
• But AI isn’t hype either. It already saves time, lowers entry barriers, and accelerates experimentation.

The truth, as usual, lies in the middle. AI is a powerful assistant, not a replacement. It can type out what you need, suggest ideas, and scaffold projects. But the design, direction, and discernment still come from humans.

Final Thoughts

The rise of AI in coding is undeniable. The percentage of AI-written lines of code is going up, but that number is misleading. Much of it is redundant or unnecessary, inflating the perception of progress. Developers remain as essential as ever, because code without thought and structure is just noise.

For organizations, the goal shouldn’t be maximizing the share of AI-written code. The goal should be efficiency, maintainability, and innovation. AI is simply one of many tools to help get there.

For developers, the path forward is clear: embrace AI’s strengths, understand its flaws, and evolve your skills accordingly. Those who learn to wield AI effectively will unlock faster workflows and new possibilities, while still applying the human judgment that machines cannot replace.

At the end of the day, AI can generate code — but only developers can create software.