A few days ago I came across a discussion in a developers group that strongly opposed the use of AI coding agents. Some of them argued that code generated through tools like Claude Code, Gemini, Codex, and similar agents should not be trusted in production environments.
Their concern was simple: code can be created and modified quickly, but that doesn't automatically make it maintainable, predictable, or safe.
I don't completely disagree with them.
There is one thing experienced developers understand very well. A software project is not just a collection of files. Over time, every project develops its own structure, decisions, trade-offs, and history. An engineer who works on a product every day understands why certain choices were made, which shortcuts were taken, and which parts of the system are fragile. An AI agent can generate files and make edits across an entire codebase, but it doesn't truly own the responsibility of living with those decisions months later.
That is where human expertise still matters.
Building Has Become Ridiculously Easy
Lately there has been a lot of discussion around whether AI will replace software developers. Personally, I don't think that future is anywhere close. What I see instead is a shift in how software gets built.
Today, a developer can describe a feature in plain language and receive a working implementation within minutes. APIs can be scaffolded. Database schemas can be generated. Authentication systems can be connected. Entire frontend screens can appear from a conversation. Tools like Claude Code, Gemini, Codex, Cursor, and even Google's free AI coding offerings have made software creation dramatically faster than it was just a few years ago.
A recent example: was a small 404 page project I built with Claude Sonnet 4.6. My first prompt was barely detailed. It was something along the lines of:
"Create me a 404 page with some HTML5 games inspired by open-source ideas.."
That was essentially the entire starting point.
The result became
It wasn't a production-scale application, but it was a reminder of how dramatically the barrier to creating software has changed. A few years ago, even a playful side project like this would have required planning the layout, finding game assets, wiring interactions together, and spending hours on implementation. Today, a rough idea can become a working prototype almost immediately.
That part is real.
Then Reality Arrives
What people often overlook is what happens after the code exists.
Building something is only the beginning. Maintaining it is a completely different challenge. Applications evolve. Requirements change. Dependencies break. Security vulnerabilities appear. Customers discover edge cases nobody anticipated. Performance issues emerge under real usage.
AI can certainly help with many of those tasks. It can refactor code, update dependencies, suggest improvements, and even identify potential problems. But in my experience, the best results still come when those actions are guided by someone who understands the product and its architecture.
Without that guidance, an AI agent can easily solve the wrong problem.
Learning While Building
This is why I think the term "vibe coding" is often misunderstood.
For developers who already understand software structure, vibe coding can be incredibly productive. If you know how APIs work, how databases relate to applications, how deployments happen, and how data flows through a system, AI becomes a powerful accelerator. You spend less time typing and more time thinking.
The situation is different for complete beginners.
Interestingly, I don't think that means beginners should avoid these tools. In fact, AI coding agents have made software development more accessible than ever. Someone without a computer degree can now build small applications, launch websites, experiment with databases, and learn through direct interaction.
That was much harder in the past.
The difference is that eventually they still run into the realities of software engineering. They need to understand why a bug occurs. They need to understand deployment environments. They need to understand how data is stored, how authentication works, and why certain architectural decisions matter.
The learning hasn't disappeared. The entry point has simply changed.
Years ago, many people believed they needed to master every language, framework, and concept before creating anything useful. Today, someone can build first and learn along the way. That doesn't remove the need for software knowledge. It just changes the order in which that knowledge is acquired.
Why Developers Still Matter
In many ways, AI has reduced the importance of memorizing syntax while increasing the importance of understanding systems.
That is why I don't see AI coding agents as being completely dependent on developers, nor do I see developers becoming obsolete. The relationship is more interesting than that.
A person with no development background can create things that previously required a team. That is an incredible shift.
At the same time, a skilled developer can use these same tools to move faster than ever before, turning ideas into working software in a fraction of the time.
The real advantage is not knowing how to prompt an AI.
The advantage is knowing what should be built, why it should be built, and whether what the AI produced actually solves the problem.
That's the part AI still can't own.
At least not yet.