I used Fable 5 to build a full-stack app without writing code. Then I found something that scared me.

I've been a software engineer for years. Recently, everyone is talking about how powerful Fable 5 is, so I wanted to find out for myself.
I tried an experiment.
I built a full-stack web app using Fable 5. No traditional coding. I described the features I wanted, reviewed the generated code, and let the AI handle the implementation.
And honestly, the first impression was impressive.
Within a short amount of time, I had something that looked like a real product. The UI was polished. Authentication worked. The database was connected. The main features were there. If I showed it to someone without explaining how it was built, they probably wouldn't guess most of it was generated by AI.
I remember thinking, "This is crazy. Maybe we're closer than I thought."
Then I reviewed the code like I would review any real production system.
That's when the excitement started to disappear.
The app looked finished, but the deeper I went, the more issues I found.
Some were small. Some were things that could become serious problems later.
There were security concerns. Some APIs trusted user input too much. There was no proper rate limiting. There were no protections against fake accounts and spam. Some database queries looked completely fine with a few users but would become a nightmare when the data grew.
I found N+1 query problems, missing indexes, performance bottlenecks, slow operations running during user requests instead of in the background, and database changes being made without proper migrations.
The weirdest part was that nothing looked broken. The app worked.
You could create an account. You could log in. You could click through the features. You could even complete a payment flow.
That is what makes this interesting.
A lot of people building with AI are not launching obviously broken apps. They're launching apps that look finished but have hidden problems waiting underneath.
A beautiful UI won't save a broken backend.
Before launching, I'd make sure you've actually tested:
• Login and password resets
• Real credit card payments (not just test mode)
• SSL on a real domain
• Separate development and production environments
• API keys aren't exposed anywhere
• Production database backups actually work
Security issues are another thing that usually don't appear until it's too late. Many apps don't get abused when they're small. They get abused after they start getting attention.
Things like:
• Email verification
• Rate limiting
• Input validation
• Basic bot protection
can make the difference between a smooth launch and waking up to thousands of fake accounts.
Performance is another trap. Everything feels fast when you're the only user. The problems appear when real users arrive. Suddenly you have slow database queries, pages loading thousands of records, expensive tasks blocking requests, and no idea what is failing because nothing is being monitored.
Pagination, database indexes, background tasks, and error monitoring are not things you add only after you become successful. They are what help you survive when you start growing.
One of the biggest lessons I took away from this: stop letting AI directly modify your production database schema.
Use migrations.
A migration is just a small file that describes a database change, like adding a column or creating a table. It runs in order, can be tracked, and keeps your development and production environments consistent. It feels like extra work at the beginning, but it prevents a lot of painful problems later.
The funny thing is, this experiment actually made me more optimistic about AI coding.
Fable 5 is powerful. It saved me a huge amount of time.
But there is a difference between generating an app and building a production system.
AI can write code incredibly fast.
But it doesn't automatically know the decisions that come from years of dealing with real users, security problems, scaling issues, and production failures.
I've been documenting everything I found because I think a lot of people are currently building and launching AI-generated apps without realizing these problems exist.
This weekend, I'm going to host a free live Zoom session with my friend who works at Google, where we will walk through the actual app, show the issues we found, explain why they matter, and go through what we would fix before putting it in front of real users. DM me if you’re interested, and I’ll send over the Zoom session details.
Overall, the part that surprised me the most wasn't that AI made mistakes. It was how convincing the app looked before I started looking deeper.
I'm curious: if you've built a vibe-coded app, what was the first unexpected problem you discovered after launching?