Prompt-to-App Generation
How tools like Lovable, Bolt, and v0 turn a prompt into a scaffolded app, and where that approach breaks down as requirements get real.
Prompt-to-App Generation
The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.
Not started
What you'll learn
- Under the hood, a prompt-to-app tool picks a stack for you before it writes a line of code — you're accepting that implicit choice whether you notice it or not.
- The first generation is really component scaffolding: a plausible file structure and a first-pass UI, not a finished architecture.
- Iterating by re-prompting works well for surface changes but poorly for anything that requires restructuring how the pieces fit together.
- Ambiguous requirements in your original prompt get resolved by the model making a guess, and that guess becomes baked into every file it generates from then on.
- The approach breaks down exactly where real engineering judgment is needed: data modeling, auth boundaries, and anything with more than one reasonable design.
What actually happens after you hit enter
When you type a description into Lovable, Bolt, or v0, nothing magical happens that’s fundamentally different from how a developer approaches a new project — it’s compressed into one step instead of many. The model interprets your prompt as a rough spec, picks a stack it’s confident generating (almost always a popular, well-documented one like React with a common component library), decomposes the request into a plausible set of components and routes, and writes code for each piece in sequence. What you get back a few seconds later is component scaffolding: files with sensible names, wired together, rendering something that looks finished. It is not architecture in the sense a senior engineer would use the word — it’s a fast, competent first draft built on default choices you never explicitly approved.
The stack choice is implicit, and it sticks
The framework and patterns a tool reaches for are rarely surfaced as a decision for you to make; they’re baked into the tool’s defaults. That’s convenient when the default fits your project and invisible friction when it doesn’t. Once the first generation happens, you’ve inherited that stack — its routing conventions, its styling approach, its way of handling state — and every subsequent prompt is interpreted in that context. This is worth noticing early, because switching stacks mid-project after several rounds of generation is close to starting over, not a quick pivot.
Iteration is re-prompting, and re-prompting has a shape
The standard workflow after the first generation is conversational: you look at what came back, describe what’s wrong or missing, and the tool regenerates the affected files. This works remarkably well for things that are genuinely local — change this button’s color, add a field to this form, fix this piece of copy. It works much worse for anything that requires the model to reconsider how pieces relate to each other, because the natural behavior is to patch the existing structure rather than question it. Ask for a new button and you’ll get a new button. Ask for a fundamentally different data flow between two components that were scaffolded independently, and you’re more likely to get a half-measure that technically satisfies the prompt while leaving the old structure limping along underneath.
Where ambiguity goes to hide
Every prompt you write leaves things unsaid, and a tool has to resolve that ambiguity somehow to produce working code. It does this the same way autocomplete does: by defaulting to whatever is statistically most common in similar contexts it’s seen. If you didn’t specify how a list should sort, it picks the ordinary choice. If you didn’t specify what happens on an empty state, it picks something plausible. Most of the time these guesses are fine. The problem is that they’re invisible — nothing tells you a decision was made on your behalf — so they surface later, often as a bug report from a user hitting the exact case your prompt never addressed.
Where the approach runs out of road
This whole model — describe, generate, re-prompt — is extremely well suited to interface work, because interfaces are mostly about plausible defaults applied consistently. It is much less suited to the decisions that define a real product: how data is modeled and related, where the boundary between trusted and untrusted input sits, what happens under concurrent access, how a schema will need to evolve. These require weighing tradeoffs against a specific, non-generic context that a prompt rarely communicates in full, and they’re exactly the decisions a generated prototype tends to get wrong or skip silently. Recognizing that boundary — where prompting stops being sufficient and real design work has to start — is the single most useful skill this stage of the process teaches.
Check yourself
What choice does a prompt-to-app tool make before writing any code?
It implicitly picks a framework and stack — component library, routing approach, state management pattern — based on its defaults, and that choice shapes everything it generates afterward.
Why does re-prompting work well for some fixes and poorly for others?
Re-prompting is effective for localized, surface-level changes like style or copy, but poor for changes that require restructuring relationships between components, since the model tends to patch around the existing structure rather than redesign it.
What happens when your original prompt leaves a requirement ambiguous?
The model silently resolves the ambiguity with whatever default is most common in its training data, and that guess gets built into the generated files, often invisibly, until a later prompt or a bug surfaces the mismatch.
Go deeper
Notes
Notes are saved to your account.
Everything else on this page works without one — progress and bookmarks keep themselves in this browser and come with you when you sign in. Notes are the one thing worth not trusting to a browser you might clear.
Your notes could not be loaded.