An honest perspective on AI, vibe coding, and why experience still matters.
I want to talk about AI. Not the hype version. Not the panic version. The version I've lived through as a working developer who has spent thousands of hours testing, building with, and learning from these tools.
I'm grateful for AI. I also don't trust it. And I think those two things can live in the same sentence.
Where I started
Years ago, I was the developer you called when your WordPress site got hacked. Or when you needed a plugin customised to do something it was never designed to do.
I'll be honest. It was soul-draining work.
You'd inherit someone else's codebase. Spaghetti code with no documentation. The kind of code that makes you question whether the original developer was writing it at 3am with one eye closed. And your job was to get in there, understand it, and make a change without breaking everything else.
If the plugin had the right hooks, you could work with it. If it didn't, your customisation was gone the moment the plugin updated. Which meant you'd start over. Study the new version. Figure out what changed. Figure out what broke. That's not an hour of work. That's four hours, eight hours, sometimes three days of reading someone else's logic and trying to make it yours.
I hated those days. But they made me.
Reading bad code taught me what good code looks like. Fighting with other people's architecture taught me how to build my own. Meeting impossible deadlines taught me how to prioritise, how to communicate when things go sideways, and how to follow through on what I promised.
Had AI existed back then, it would have saved me hundreds of hours. But here's the question I keep coming back to:
Would I be the developer I am today if a machine had done the hard work for me?
I honestly don't think so.
Growing up as a developer
The WordPress years gave way to custom software development. I became obsessed with security, speed, and stability. Sometimes too obsessed. I've locked myself out of my own systems more times than I'd like to admit because I pushed the security dial too far. But that's the cost of caring about it.
Over time, the work shifted. It stopped being "can you do the job?" and started being "we need it done yesterday." The proving phase faded. Confidence grew. Not the fake kind. The kind that comes from years of solving problems that didn't have clean answers.
You reach a point where you can walk into almost any codebase, any client problem, any deadline, and know you'll find a way through. Not because you're smarter than anyone else. Because you've been in enough hard situations that the pattern recognition kicks in before the panic does.
That's experience. And there is no shortcut to it.
Then AI arrived
I'll admit it. My first reaction was: all of this effort, for what?
Every big technology shift hits the same nerve. The people who built their skills the hard way suddenly feel like the ground is moving under them. That's normal. That's human.
But panic is not a strategy. So instead of resisting, I invested. Thousands of hours. Every major model. Local setups, cloud setups, production environments. I didn't just read about AI. I put it to work and watched what happened.
And what happened was complicated.
What AI is genuinely good at
I'll give credit where it's due. AI has made me faster at the work I was already good at.
The repetitive stuff. The boilerplate. The patterns I've written a hundred times before. AI handles that and gives me time back for the work that actually needs my brain. New features. Architecture decisions. The thinking that can't be templated.
Testing is the big one. Unit tests, integration tests, end-to-end testing. The stuff that clients didn't always want to pay for, so it got half-done or skipped entirely. AI has made it possible to build proper test coverage without doubling the project timeline. That matters. That saves businesses real money and real pain down the road.
And then there's automation. This is where I focus most of my attention these days. Because automation gives you deterministic results. You build it, you test it, it runs the same way every time. AI can help you build the automation faster. But the automation itself is reliable in a way that raw AI output is not.
That distinction matters more than most people realise.
What AI is dangerous for
Now for the part that's going to make some people uncomfortable.
Vibe coding. The idea that you can describe what you want, let AI generate the code, and ship it.
I've tested it. Extensively. I wanted to know exactly how worried I should be about my career. And I can say with confidence: it is not replacing experienced developers or engineers anytime soon. Not if you care about what you're shipping.
Here's the problem. It doesn't matter how many guardrails you put in place. How many governance rules. How much context you feed it. At some point, the model decides it has a better idea than the instructions it received. Just for a moment. Just one creative detour. And that detour ends up in your codebase.
I've watched it happen over and over. The moment you stop reviewing every line, it slips something in. Sometimes it's harmless. Sometimes it's the kind of change that breaks things three weeks later when nobody remembers what happened.
For a prototype? For a quick demo to test an idea? Fine. Vibe code all day. That's a legitimate use case. It's genuinely great for getting quick feedback on whether an idea has legs, instead of finding out weeks down the road that it doesn't.
But for production software? For systems that handle customer data, process payments, manage operations? No. Not without experienced eyes reviewing every piece of it.
The responsibility question
This is the part that keeps me up at night.
Software engineers carry responsibility for what they ship. When something breaks, when data leaks, when a system goes down, someone has to answer for it. That's always been the deal. You write it, you own it.
The new wave of AI-generated code is creating a generation of builders who haven't internalised that weight. Not because they're bad people. Because they haven't lived through the consequences yet. They haven't had the 2am call where a client's system is down and the only person who can fix it is you. They haven't had to explain to a business owner why their data was exposed.
That experience changes how you write code. It changes how you test. It changes how you think about every decision.
If you're building software for other people's businesses, for their customers, for their reputation, you need to understand what you're responsible for. Code is not just logic. It's liability.
I'm already watching this play out. Businesses that went with the cheapest, fastest AI-generated solution are starting to discover what was cut to make it cheap and fast. The lawsuits haven't started in earnest yet. But they will.
If you're a business owner reading this: ask your developer how the code was built. Ask them if they reviewed it line by line. Ask them what happens when something breaks. If they can't answer those questions clearly, that should tell you something.
What AI actually is
I use AI every day. I'm grateful for it. It feels like having a superpower at times.
But I've also learned what it is at its core. It's a language model predicting the next token. It doesn't understand your business. It doesn't understand consequences. It doesn't feel responsibility.
It is very, very good at sounding confident while being wrong. It will try to impress you. It will present bad ideas with the same conviction as good ones. And if you don't have the experience to tell the difference, you won't catch it until the damage is done.
Think of it as a brilliant, tireless junior who has read everything on the internet but has never shipped anything to production. You wouldn't let that person deploy to your live server unsupervised. Don't let AI do it either.
Our job, as the experienced ones, is to be the guardian. Every time. Not most of the time. Every time. Because the moment you look away is the moment it makes a choice you didn't ask for.
The question that matters
So here's where I land.
AI has changed the landscape permanently. It's not going away. Adapt or be left behind. I believe that completely.
But the hard road I walked — the WordPress suffering, the spaghetti code, the impossible deadlines, the clients who tested every limit of my patience and my skill — that road made me the developer I am. The experience I carry isn't just knowledge. It's judgement. It's the ability to look at a piece of code and feel that something is wrong before I can explain why.
AI doesn't have that. Not yet. Maybe not ever.
So use AI. Learn it. Build with it. Let it handle the repetitive work so you can focus on the work that matters. Use it to build better tests, better automation, better workflows.
But don't skip the hard road entirely. Because the hard road is where the judgement comes from. And judgement is the one thing AI cannot generate.
Still learning the practice of coding & architecting. Every day.
Anton de Villiers Founder, VVW Software