What 200+ Hours of AI Development Taught Me About Building with Lovable.dev
On This Page
We’re all software engineers now. Type it and AI will make it for you.
Since mid-2024, I’ve spent 200+ hours working with Lovable.dev, building over 60 different projects along the way.
If you’re unfamiliar with this tool, Lovable is an AI software engineer that codes full stack apps for you when you chat with it.
Starting screen when you log into lovable.dev
Out of the box it codes in the popular React/Typescript frameworks, and it can easily integrate with APIs that are well-documented. Integrating ChatGPT, Airtable, or Stripe is easy because it already knows the right way to set them up for you.
It uses Supabase for a backend, and can fully handle building and managing your database (if it’s not too complicated).
Across many power sessions with the platform, I have developed a deep understanding of how to get more out of AI-assisted software development, and how to think about working with AI in order to achieve more.
Through trials with the early version of the platform (formerly known as GPT Engineer), I've watched it evolve into something remarkable.
And I’ve found the best way of working is not to jump straight into code generation, but instead first establish a shared cognitive framework that lets AI explore solutions you might not have conceived on your own.
Here are 5 “laws” of working with Lovable, an AI software engineer.
Establish Intent and Solution Space First
The key is creating a shared understanding of what you're trying to achieve, and then setting the AI on a track to explore and mine the latent possibilities in that problem/solution space.
Don't just tell it what to build - help it understand the problem space you want to explore.
And once it “gets it”, tell it to explain itself and then save that explanation in a /docs folder. This folder then becomes your anchor. You can also update the Knowledge panel in Lovable with this info to remind it of:
Your overall project thesis / explanation
Where your reference docs are housed in your repo for easy access
This lets Lovable build complex and thoughtful software that you might not have envisioned yourself.
The best time to start doing this is after the first project message, which Lovable uses to initialize much of your project.
Engineer The AI's Thinking Process
I've found that having Lovable approach the systems architecture work from specific perspectives offers a more layered method of AI software development.
It shouldn’t just be my perspective powering the process… It should include the perspectives of roles like:
Senior UX Strategist: Balances high-level vision with tactical execution
Product Manager: Focuses on user needs and feature prioritization
VP of Product: Considers long-term impact and strategic alignment
Cognitive Architect: Pushes AI to build thinking steps rather than hardcoding solutions
This last role - Cognitive Architect - is crucial for AI-powered features. Instead of letting AI default to static implementations, this perspective pushes it to develop actual reasoning pathways in the software.
“Review the overall user flow of this component for admin users. What would the Senior UX Strategist and Product Manager separately recommend, based on their expertise?”
This superpositional approach to building means we’re only executing changes that have been considered from multiple key angles.
Create Persistent Memory Through Documentation
Your documentation is active thought infrastructure for Lovable.
By documenting Lovable’s reasoning process in your repo, it creates a framework that shapes future problem-solving.
In my case, I often ask Lovable to document key decisions and reasoning flows, then reference this documentation before making changes. This creates continuity of thought across development sessions.
“Continue with the next pertinent activity on src/docs/email-system-updates.md. Once you complete your code edits, prior to terminating your lov-code block you will update src/docs/email-system-updates.md with checkmarks to denote completed activities.”
Over time, you build a structured understanding of how to think about your specific problem space.
Before implementing updates, have Lovable review its own documentation to maintain consistency.
Work in Cycles: Expand, Refine, Integrate
Rather than one-shot requests, I've found success working in structured cycles:
Expansion: Let AI explore broad possibilities from different perspectives
Refinement: Focus and optimize promising directions
Integration: Lock in learnings through documentation
Diverge, Converge, Integrate. This let’s us apply design thinking to each “move” that we’re trying to make towards our desired software solution.
Plus it layers over time – this is a compounding activity.
Invest in Intelligence
Yes, this approach sometimes uses 2-3 credits to get something done instead of one.
But the return on investment is exponential.
Instead of fragmented feature requests, you get software that is well-designed for AI to work with.
The Future of AI Development
What I've learned over hundreds of hours is that as much as Lovable is an “AI engineer”, it’s also a solution explorer that can help you build software beyond what you might imagine yourself.
The key is setting up the right cognitive frameworks and letting AI reason within them.
From my POV, this is the future of software development. Fully automated coding can only achieve so much. Human-AI collaboration has much higher ceiling of capability and impact.
For those willing to invest in understanding how to guide AI's thinking process, the possibilities here are extraordinary. Go build!
