It's no secret that AI models have come a long way since the early days. They've become one of the most useful tools available to developers around the world. At this point, AI feels as essential as our IDE. Many of us rely on it daily, and without it we sometimes feel slower or left behind.
But I've been thinking about one question lately.
Is AI actually making us faster?
Or does it simply make us feel more productive?
Every few months we hear another announcement.
"100 billion parameters."
"State-of-the-art coding benchmark." "95% on benchmark X."
The numbers keep getting bigger, and companies proudly showcase them.
But here's the question I rarely see people asking:
How much do these benchmarks actually affect a developer's day-to-day work?
Writing production software isn't a benchmark. It's understanding requirements. Debugging edge cases. Making trade-offs. Reading legacy code. Communicating with teammates.
Benchmarks measure capability. They don't always measure real-world productivity.
One study that really caught my attention came from METR (Model Evaluation & Threat Research).
Researchers found that experienced open-source developers working on their own repositories were about 19% slower on average when using AI tools for the tasks they studied.
That doesn't mean AI is bad. Nor does it mean AI always makes developers slower. But it does challenge an assumption many of us have.
Sometimes we mistake activity for productivity.
Developers often spend more time:
We're busy. But are we actually moving faster? Or are we simply moving differently?
"What gets measured gets managed."— Peter Drucker
If all we measure is how quickly AI generates code, we ignore the time spent reviewing, validating, and maintaining that code. Absolutely not. I think AI is one of the greatest tools developers have ever received.
The problem isn't AI. The problem is how we choose to use it.
If we completely offload our thinking to AI, we'll eventually lose the understanding needed to solve problems ourselves. AI should assist your thinking not replace it.
When something breaks in production, you can't simply depend on AI to explain everything. You need to understand your own architecture, your own decisions, and your own codebase.
That's why I still believe developers should own the architecture, understand the trade-offs, and review every important decision.
AI is the assistant. You're still the engineer.
Larger models are impressive. They're often more capable.
But I don't think a larger model automatically makes someone a faster developer.
A skilled engineer using a lightweight model, clear context, and good engineering practices can often outperform someone using the latest flagship model without fully understanding what they're building.
The model matters. But the developer matters more.
A non-technical user may benefit from the most powerful model because they want AI to handle everything.
Developers are different. We aren't just trying to generate code. We're trying to build software we understand, maintain, and improve.
AI isn't a magic wand. It's a tool.
Whether it makes you faster depends less on the model you're using and more on how you're using it.
The developers who benefit the most from AI are usually the ones who think critically, understand their systems, and use AI to eliminate repetitive work not to replace engineering.
💭 This is just my perspective, and I'd genuinely love to hear yours.
Outside of writing, I'm also building MyTreep, a platform that makes travel planning easier and faster.
If that sounds interesting, I'd genuinely appreciate your feedback. That's all for now.
You can follow me here on dev.to for more articles and on X ** @emekaugbanu**.