A few months ago, I wrote about rediscovering Ruby on Rails and the growing era of “vibe coding”—a workflow where AI helps us move faster, reduce friction, and focus on higher-level architecture. That trend continues, and tools like Cursor have only accelerated it.
Cursor recently began launching a set of lessons for getting the most out of their AI IDE, and they’re genuinely excellent resources. While they have only released a handful of lessons to date they clear and easy to understand; provide working examples and set the foundations for when they get more detailed. If you’re curious: https://cursor.com/learn
But as good as this new wave of AI-assisted development is, it’s important to restate a truth that often gets lost:
AI doesn’t automatically turn non-developers into developers.
And more importantly:
AI doesn’t replace the experience required to recognize when the AI is wrong.
AI Still Makes Confident Mistakes
Even today, the most advanced coding assistants make authoritative—but incorrect—assumptions.
A very fresh example: while working with a third-party library, the AI confidently suggested intercepting a specific event. It wrote the code, wired up the handler, and explained exactly how the event would flow.
One problem:
The event didn’t exist.
Only when I explicitly asked the AI to read through the actual source code of the library did it realise that its initial suggestion was a hallucination. It guessed the event name based on patterns it had seen elsewhere—and got it wrong.
A junior developer might do something similar, but the difference is crucial: an experienced developer can quickly spot that something “smells off.” A non-developer or early junior may not.
AI Agents Are Not Autonomous Engineers
Cursor describes this dynamic particularly well in their lesson on agents:
“Think of agents like fast junior developers who need clear direction, who also can easily forget things, so they require oversight. They can get stuck in loops, repeating the same failing approach without recognizing they need a different strategy.”
— https://cursor.com/learn/agents
This is the perfect framing.
AI assistants are fast.
They’re helpful.
They can unlock productivity you simply don’t get from traditional tooling.
But they are not senior developers.
They are not architects.
And—crucially—they are not responsible for correctness.
You are.
AI Raises the Floor, Not the Ceiling
I genuinely believe AI is transforming software development, and it’s only accelerating from here. It does raise the floor—people with little experience can achieve things previously out of reach.
But the ceiling still depends on human judgment, experience, and the ability to reason about the problem space.
AI can propose code.
AI can scaffold an app.
AI can refactor, explain, and optimise.
But AI cannot yet:
- Validate architectural choices
- Detect subtle conceptual errors
- Spot when a generated solution contradicts the underlying system
- Recognise when it made up an API call or event that doesn’t exist
- Apply pragmatic tradeoff thinking
The Future: Developers Who Use AI vs Developers Who Don’t
The real divide emerging in our industry isn’t between developers and non-developers—it’s between developers who can leverage AI effectively and those who can’t.
AI is a multiplier.
If you bring experience, context, and judgment, it makes you dramatically more productive.
If you don’t, it can amplify your mistakes.
And just like a junior developer, AI needs guidance, constraints, and oversight.
The magic happens when you combine AI’s speed with human intuition and expertise.
Leave a Reply