AI can write the code. But you still have to know what you’re building.
About a year ago, I decided to try an experiment. I wanted to see if I could build an entire WordPress website using AI. Not just a few snippets of code here and there, but an actual functioning website, built almost entirely through prompts.
And because I apparently enjoy making things difficult for myself, I wasn’t going to build a simple brochure site.
The project was TRĪB, a parenting resource website with some fairly complex functionality.
I wanted a faceted product search that would allow parents to find diapers based on features, sizes, and retailers. Individual product pages would display detailed information, with dropdowns linking to different retailers for each available size.
Beyond that, I wanted community forums, aggregated articles and videos that could be filtered by topic or age group, and a directory of local parenting resources organized by Northern California counties.
All built in WordPress. All through prompts.
What could possibly go wrong?
Well, It Actually Worked
The first thing that surprised me was just how capable AI was at doing the heavy lifting.
I’ve spent years working in web development, so I have a pretty good understanding of what’s involved in building this kind of functionality. Custom post types, taxonomies, PHP, JavaScript, database queries, templates, all the fun stuff.
And here was AI generating working code in minutes that would have otherwise taken me hours.
It was pretty crazy. And cool.
I could describe a feature, explain how I wanted it to behave, and watch AI put together the underlying code. Sometimes it worked right out of the gate. Other times it needed some tweaking. But the speed at which I could move from an idea to something functional was unlike anything I’d experienced before.
I wasn’t spending my time writing code. I was spending it thinking about what I wanted to build.
And that was pretty liberating.
And Then It Broke Something
Of course, there’s another side to this story.
AI has an occasionally maddening habit of fixing one thing while breaking three others.
I’d ask it to make a small adjustment to a feature that was already working, and suddenly something completely unrelated would stop functioning.
Then I’d ask it to fix that problem, only to discover that the fix introduced another problem.
And so on.
There were times when I felt like I was playing whack-a-mole with my own website.
What I eventually realized was that AI had a tendency to do more than I asked. Rather than making a surgical change to existing code, it would sometimes rewrite entire sections, introducing unnecessary changes and creating what I came to think of as derivative development.
I was spending time fixing problems that didn’t exist before I’d asked it to make an improvement.
And the really funny part? AI would confidently tell me everything was fixed.
It wasn’t.
Apparently, I Needed to Learn How to Ask
This was probably one of the biggest lessons of the entire experiment.
I had to become much more thoughtful about how I prompted AI.
Early on, I’d give it broad instructions, explain what I wanted, and let it figure out the details. That worked reasonably well when creating something new. But when modifying existing functionality, it could be a disaster.
I learned to break things down into smaller tasks. Be specific about what needed to change. Explicitly tell it what not to change. And, perhaps most importantly, test each change before moving on to the next.
Essentially, I had to learn how to manage AI like a developer.
Which is interesting, because I’ve spent a good portion of my career doing exactly that with actual humans.
The difference is that AI can generate an enormous amount of code in seconds, which means it can also create an enormous amount of trouble in seconds.
And even after learning to be more deliberate, I didn’t always get it right. Sometimes I’d think I’d written a perfectly clear prompt, only to discover that AI had interpreted it in a completely different way.
So we’d go back, clarify the details, and work through the problem one piece at a time.
Not exactly the magical, effortless future of software development we’ve all been promised.
But it worked.
Just Because It Works Doesn’t Mean It’s a Good Experience
Another thing I learned is just how important having a good eye for user experience really is.
AI can generate a perfectly functional interface. It can create navigation, filters, forms, buttons, and all sorts of interactive components. But left to its own devices, it doesn’t necessarily understand how those pieces should work together as a cohesive experience.
And that’s where things can get weird.
You might end up with one page using a particular navigation pattern, another page doing something completely different, and a third introducing an entirely new approach to accomplishing essentially the same task.
Individually, everything might work. But collectively, the website can become a disjointed mess.
Different spacing, inconsistent typography, awkward layouts, unnecessary interactions, and design decisions that seem perfectly reasonable in isolation but make absolutely no sense when you look at the website as a whole.
It’s the digital equivalent of building a house where every room was designed by a different architect.
Sure, all the rooms are there. But why is the bathroom door in the kitchen?
This is where having an understanding of UX, visual hierarchy, consistency, and how people actually interact with websites becomes incredibly important.
You need to recognize when something feels wrong, even if it’s technically functioning exactly as requested.
You need to understand the journey someone takes through the website, how information is organized, and whether the interface makes sense to the person using it.
And you need to establish some basic design principles and patterns that AI can follow rather than allowing it to reinvent the experience with every new feature.
AI can build the pieces. But someone still needs to make sure they fit together.
Without that oversight, you can end up with a technically impressive website that’s an absolute nightmare to use.
Experience Still Matters
One thing this experiment really reinforced is the value of understanding the technology you’re working with.
I’m not a developer who spends his days hand-coding everything from scratch. But I understand how websites work. I understand WordPress, content management, front-end development, data structures, and how the various pieces fit together.
And just as importantly, I understand how to approach building an experience that makes sense to the people using it.
That background made an enormous difference.
When something broke, I generally had an idea of where the problem might be. When AI suggested a solution, I could evaluate whether it made sense. And when it started heading down the wrong path, whether technically or visually, I could recognize it and redirect the work.
I think this is where the conversation about AI replacing developers and designers gets a little misguided.
There’s a big difference between generating code, creating an interface, and understanding what makes a good website.
AI can do the first two remarkably well.
The third still requires judgment, experience, and an understanding of what you’re actually trying to accomplish.
At least for now.
So, Was It Worth It?
Absolutely.
Despite the frustrations, I’ve been able to build and deliver functionality in a fraction of the time it would have taken me otherwise.
Complex product filtering, dynamic product pages, community features, resource directories, and custom WordPress functionality that would have required a considerable amount of development time became manageable.
More importantly, I could experiment.
I could come up with an idea, test it, see how it worked, and refine it without investing days in development just to find out whether it was worth pursuing.
That changes things.
It makes complex functionality more accessible to smaller organizations, independent creators, and people with ideas who don’t necessarily have the resources to hire an entire development team.
But it also comes with a responsibility to understand what you’re building and to make sure it actually works.
And not just technically.
A website needs to be intuitive, consistent, accessible, and useful. It needs to solve problems without creating new ones for the people trying to use it.
Because generating code quickly doesn’t mean you’ve generated good code.
And generating a website doesn’t necessarily mean you’ve created a good experience.
A Year Later
Looking back, this experiment has fundamentally changed how I approach building websites.
I’ve learned to be more precise with requirements, more disciplined about testing, and more careful about making changes to working functionality.
I’ve also learned that having a clear vision for the user experience is every bit as important as understanding the technology behind it.
There are still moments when I find myself arguing with a machine about why it changed something I specifically told it not to touch.
Which, when you think about it, is a pretty ridiculous way to spend an afternoon.
But then I’ll watch it build something in fifteen minutes that would have taken me an entire day, and I’m reminded why I started this experiment in the first place.
I don’t think AI is going to eliminate the need for people who understand web development or design. I think it’s going to change what those people spend their time doing.
Less grunt work. More problem-solving, architecture, user experience, and creative thinking.
And I’m all for that.
A year ago, I wanted to find out whether I could build a complex WordPress website entirely through prompts.
Turns out I could.
But I also learned that AI doesn’t replace experience, judgment, or a good eye for design. It amplifies what you bring to the table.
And occasionally, you still need to tell it to leave something the hell alone.
