Three Lovely Projects And One Failure
How I Learned to Stop Coding and Love the Result
Lovable.dev bridges the gap between idea and reality — taking web development from complex to simply doable. Unlike traditional frameworks with their steep learning curves, Lovable puts developer experience first while delivering powerful tools for engaging applications.
This post details my journey with Lovable through three successful projects and one that didn’t quite meet expectations. What makes this article different is its interactive nature — I encourage you to experience these projects firsthand as we discuss them.
Throughout this post, you’ll see links to the actual projects. For the full impact of this discussion, I recommend typing in these URLs and exploring the sites yourself. Screenshots can only capture a moment, but interacting with these projects will give you a genuine understanding of what worked, what didn’t, and why.
Ready to see how Lovable can transform your development process? Let’s dive into what this platform can (and occasionally can’t) deliver, based on my hands-on experience building with it.
Lovable: The Tool, The Team, The Promise
Lovable.dev is redefining software development by turning natural language prompts into full-stack web applications. Founded by Anton Osika, Lovable’s mission is to make app creation effortless, empowering developers and non-developers alike to bring their ideas to life — without the usual complexity.
The Tool
Lovable offers a streamlined, AI-powered workflow that transforms ideas into working applications:
- AI-Driven Development: Users can describe their application ideas in natural language, and Lovable generates responsive front-end applications tailored to these descriptions.
- Backend Integrations: The platform supports integrations with services like Supabase, enabling the addition of databases and authentication systems to projects.
- GitHub Porting: Lovable allows users to sync their codebases with GitHub, facilitating version control and collaboration.
The Team
Based in Stockholm, Sweden, the Lovable team is made up of passionate innovators constantly evolving the platform. They host frequent livestreams, roll out new integrations every other day, and recently rewrote their massive codebase from python to Go to improve speed and concurrency.
The Promise
The mission of Lovable is to make software development accessible to all, removing traditional barriers and empowering users to bring their ideas to life quickly. Whether you’re a solo creator or a scaling SaaS startup, Lovable lets you focus on what matters: bringing great ideas to life.
The Pricing
The free plan includes unlimited public projects, GitHub sync, and one-click deployment. On this plan, you get 5 messages per day, with a total limit of 30 messages per month. While 5 messages isn’t much, I found it sufficient for basic applications.
The paid options offers many features like higher limits, private projects, custom domains and more. You can check it out at the pricing page.
The Projects
All projects I’ll be sharing were built entirely on the free plan (+promo code from Christmas), showing what’s possible even with these limitations. Let’s explore what I created, and where I stumbled, without spending a cent (so far).
Project #1 — Spelling Dojo
As a native Hebrew speaker who suddenly found myself writing more in English for Medium and Substack, I faced a challenge: my spelling and grammar needed work. Despite having access to autocomplete and AI tools, I wanted to improve my actual skills. After searching unsuccessfully for a free app to help me practice, I decided to build one myself using (of course) Lovable.
My journey began with a simple prompt: “I want a simple app to fix my spelling in English.” Through collaborative iteration with Lovable’s AI, we refined the concept into what became Spelling Dojo.
The application follows a straightforward but effective model. Users are presented with a misspelled word (like “embarrasment”) and must provide the correct spelling (“embarrassment”).
The training progresses through ten batches of ten words each, gradually increasing in difficulty. I added features to enhance the learning experience: an audio pronunciation option, definitions for unfamiliar words, and even a “hard mode” that provides only the word’s definition without showing the misspelling.
Unlike a real dojo where mistakes might earn you a stern correction from a sensei, Spelling Dojo takes a gentler approach. When you make an error, the feedback is soft and encouraging, allowing you to try again without penalty or stress. This judgment-free environment was intentional — I wanted a practice space where users could fail comfortably and learn at their own pace, without the anxiety that often accompanies language learning (I’m looking at you Duolingo!).
Experience it yourself: https://spelling-dojo.lovable.app/training
This project perfectly demonstrates how AI development tools can help create personalized solutions for specific needs. In just a few iterations, I went from identifying a problem to having a functional, tailored application that addressed my exact requirements — something I couldn’t find despite searching through existing solutions.
Project #2 — Funniest Substack Counter
My second project shifted away from practicality and into the realm of pure fun. Anyone who’s spent time on Substack knows a universal truth: Substackers are obsessed with their subscribers counter. This fixation gave me the perfect opportunity to create something light-hearted that would connect with the Substack community.
I approached Lovable with this initial prompt: “Hey, I got cool idea. I want to have dedicated page to follow my substack subscriber count and tell a funny fact about it. You should give funny facts about it until 500 or autogenerate it. My substack link is https://open.substack.com/pub/shmulc". From this starting point, we built out the concept, eventually expanding it to accommodate other publications beyond my own.
One significant technical challenge emerged early on — Substack doesn’t offer a public API to access subscriber counts. After several failed attempts where Lovable initially generated completely fictional numbers, I pushed for a better solution. Eventually, the app implemented a clever combination of web scraping with rate limiting and proxy techniques to accurately fetch real subscriber counts without triggering Substack’s defenses.
The generated facts proved to be surprisingly entertaining. My strategy to share the tool was simple but effective: I created fun facts for fellow Substackers and tagged them, essentially turning the tool into a social connector.
The project succeeded on its primary metric — bringing smiles to faces. While it may not solve profound problems like Spelling Dojo, it created moments of joy and connection in the often serious world of content creation.
You can see it in action and generate facts for your own publication at: https://funniest-substack-counter.lovable.app/
Project #3 —Turtle Sanctuary
Everyone who knows me knows one important fact: I absolutely adore turtles. These magnificent creatures are, in my completely unbiased opinion, the cutest animals in the entire animal kingdom. Any opportunity to discuss or see turtles brings me immense joy.
With this project, I had ambitions beyond simply celebrating my favorite animal. Unlike my previous apps, I wanted to tackle a technical challenge that had long intimidated me — implementing the majestic “Continue with Google” authentication button that appears on so many professional applications.
Lovable’s built-in integration with Supabase (an open-source alternative to Firebase) provided the perfect opportunity. Supabase offers robust features including authentication and database services, with Lovable handling much of the heavy lifting for queries and database operations automatically.
By combining my passion for turtles with my technical goals, I created a simple but functional Turtle Sanctuary app. Users can add new turtles to their sanctuary, then feed, pet, rest, or play with them. The true achievement, however, is that you can log out and log back in with your Gmail account — and your turtles remain right where you left them!
Configuring Gmail authentication properly took several hours of focused work (details I’ll spare you in this post), but the end result was deeply satisfying. While the sanctuary itself may not have every feature perfectly polished, it accomplished my primary goal: mastering authentication that I can apply to future projects.
Experience the sanctuary and test the authentication yourself at: https://turtle-sanctuary.lovable.app/login
Project #4 — FGSM Demo: A Beautiful Failure
The last project I want to share is one that didn’t succeed — but failures often teach us more than successes, which is why this project deserves its place in this post.
A few weeks ago, I wrote about FGSM (Fast Gradient Sign Method) in my “Cracking The Black Box” post. This technique creates adversarial examples that can fool image classifiers. I wanted to build an interactive demonstration where readers could upload their own photos or choose from examples, see how a basic classifier would categorize them, then apply FGSM with a target category and witness the classifier being fooled despite minimal visual changes to the image.
Naturally, I turned to Lovable with this prompt: “Please create for me a small app that will showcase FGSM. The user will be able to upload photos or choose from examples, the web will show the original prediction with some basic image classifier and then after FGSM on the image and some target choosing (that the user will be able to search from the options of the classifier), the classifier will predict again with the diff between the image and if there was success.”
The result was stunning, with much more beautiful images then I could find and Excellent UI. But there was one problem — It didn’t work.
Two major issues plagued the application. First, it generated fake values for some predictions rather than calculating them properly. Second, applying the “attack” actually made the classifier more confident in its original assessment rather than fooling it — the exact opposite of what FGSM should do.
I repeatedly tried to fix these issues through the chat interface, but even after multiple attempts, the core functionality remained broken. After exhausting my daily message credits, I accessed the GitHub repository and attempted to fix the problem myself, suspecting it might be a simple plus/minus error somewhere. I even enlisted devin.ai to help, which successfully fixed minor issues like the broken image upload functionality but couldn’t resolve the fundamental FGSM implementation problem.
The experience was frustrating, but it taught me several valuable lessons:
- Some algorithms contain subtle details that can be difficult to implement correctly, especially when working with a platform focused on web app creation rather than ML implementation.
- It’s crucial to ensure core functionality works before expanding features or polishing the UI.
- While it’s possible to work with Lovable apps outside the platform (I managed to set it up locally and make some changes), there are limitations.
- Sometimes, the wisest decision is knowing when to walk away.
In the end, I published “Cracking The Black Box” without the interactive demonstration, and it still turned out to be an excellent post. This project was another step in my journey — not all steps move forward, but each one teaches us something valuable.
That concludes my Lovable journey! I hope these projects have inspired you or taught you something useful. I’d love to hear about your own successes and (especially) failures with similar tools!
