With the surge of “vibe coding” tools in our workspaces, I’ve always been intrigued by those blog posts claiming, “I’m a non-programmer and I built a production app over the weekend.” So when an opportunity came to create a small POC for a client, I decided to test that claim myself—using “Lovable”, a tool some teammates had recently used for UI prototyping.
What Worked
1. Fast, Beautiful UI
The client needed a quick MVP and we had a clear idea of what we wanted. I sketched the screens on paper and uploaded them. Lovable generated a clean, slick UI—though it added a bit more flair than I asked for. Apparently, it thought my minimal dashboard needed some sparkle!
2. A Working App in Minutes
On the first run, I had a fully clickable, hardcoded app—complete with pop-ups, progress bars, and page transitions. Very impressive.
However, the free tier’s 5 credits/day was limiting. And giving multiple instructions per prompt didn’t always work—it would forget or skip parts even with clear bullets. Eventually, we subscribed to get the full experience.
3. No-Code, Clickable Prototype
Without writing a single line of code, I had a working front end. Peeking at the generated code, I noticed some logic duplication, but the prototype worked for a basic walkthrough. It was fast, easy, and surprisingly good for simple tasks.
Where It Struggled
1. Making It Functional Was Painful
Things fell apart when we moved beyond the static UI:
- Database Design: Even creating a simple schema with three related tables tripped it up.
- Architecture: It ignored basic best practices—no reuse, minimal modularity, and lots of copy-pasted logic. I winced more than once.
- Fixing Bugs = Rewrite Everything: A small screen-refresh request caused it to duplicate an entire notification logic block. When prompted, it admitted: “Oh, I could’ve reused the existing subscription.”
Eventually, I had to write pseudocode just to avoid it rewriting the entire app. If you can’t guide it precisely, you’ll burn credits fast—and potentially end up worse off than when you started.
2. Debugging Was Frustrating
Lovable doesn’t support proper debugging unless you export to GitHub and use an IDE—something I avoided to stick with the “no-code” experiment. But with manual logs being the only way to trace events, I ended up wasting credits just trying to figure out what broke.
Conclusion
Did I build a production-ready app without coding? Not really.
I had to fall back on my programming experience—logic, architecture, debugging—to get anything working beyond the basics.
But it wasn’t a complete failure:
- It accelerated UI development
- ✅ Handled basic Supabase integration out of the box
- Managed simple interactions well
- ⚡ Delivered a hardcoded prototype quickly
If you want to try this, here’s what I’d recommend:
- Let Lovable handle the UI
- Be very specific about your app’s architecture
- Use it for simple actions like click handlers and navigation
- Export and continue in a proper IDE with GitHub Copilot or another assistant
Overall, the experience was like working with a bright fresher—someone great at boilerplate, but who needs regular review, feedback, and correction. So all those claiming to be non-programmers but building prod level code, please own up your programming skills 🙂
If anyone’s truly built a real, prod ready, functional app without coding knowledge using tools like these—please drop your process in the comments. I’d love to learn how!
Anshulee Asthana
Co-Founder, Cennest Technologies