How to prompt Lovable, section by section
A Lovable prompt that builds right the first time has eight parts: the context, numbered features, a visual direction, the states, a build order, what must stay untouched, the channel your users come from, and a last line asking Lovable for its questions before it writes code. Lovable's own docs, read on 23 October 2026, now open their prompting advice with that last line, and on my runs it drew up to 5 questions before a single file existed. Build yours below, then see what each section changed in a measured build.
By Marco Kohns · Every run in my own Lovable workspace, credits read before and after
Build your prompt
What should your first Lovable prompt say?
Your prompt
8 sections · 201 words
# Context A habit tracker for team leads who run remote teams, so they see in one minute who kept their habits this week. ## Core Features (Priority Order) 1. Sign-in with email 2. A table of habits per person 3. A modal to add a habit 4. A weekly summary card per person ## Visual Style & Design Inter for body text, 8 px spacing grid, one accent colour for primary actions, shadcn Card and Table. ## Technical Requirements Every list and form has an empty state, a loading skeleton and a retryable error. Mobile first, usable at 390 px. ## Implementation Strategy Build static layout and copy first, then data and sign-in, then the features in the numbered order. ## Safe-Guard Instructions Never expose another team's data. Do not change the sign-in pages once they work. ## Growth Features (Organic SEO / AI search) Server-render every public page with one H1, a unique title and meta description, clean URLs and a sitemap.xml, so search engines and AI answers can read it. ## Before Building Ask me any questions you need in order to fully understand what I want before you write code. Save my answers to the project knowledge.
Assembled in your browser; nothing is sent or saved. Paste it into Lovable in Build mode and answer its questions before it builds.
Already have a prompt? The prompt checker and eight before-and-after rewrites test it against the same rules. Want one written for you from an idea? The generator writes all eight sections.
The anatomy
What goes into a Lovable prompt, and what does each part change?
Every one of the 122 library prompts follows this order. The right column is what the section did on a run, or the rule it answers in Lovable's docs.
- 01
# Context
What the app is, who it is for, the one job it does, and where its visitors come from.
The landing page prompt names its traffic source in line one; the run built one offer and one action in 1.8 credits.
- 02
## Core Features (Priority Order)
Numbered, so the first item exists before the fifth if a run stops early.
All five numbered features came back in one round on the landing page run.
- 03
## Visual Style & Design
Fonts, colours, spacing and named components. Adjectives such as modern leave the choice to Lovable.
Without a committed direction Lovable asks: the SaaS run spent its fourth question card on three visual directions.
- 04
## Technical Requirements
States, validation, breakpoints and accessibility, stated before the first screen exists.
The states prompt said first-use and cleared empties are never the same screen; the gallery rendered them as two cards.
- 05
## Implementation Strategy
The build order: static content first, then data and sign-in, then features in priority order.
Stops Lovable generating screens it cannot wire to anything yet.
- 06
## Safe-Guard Instructions
What stays untouched on every later edit, and what never leaves the server.
Lovable's best-practices page asks for the same thing: say what to change and what to leave alone.
- 07
## Growth Features
The mechanics the chosen channel needs: indexable pages for search, an invite loop for product-led growth.
The section the other prompting guides leave out, and the reason this library exists.
- 08
## Before Building
Ask Lovable for its questions first, then save the answers to project knowledge.
2 questions on the states run, 4 on the SaaS run, 5 on the SaaS landing page, all before any code.
Measured
What happens when a prompt asks Lovable for its questions first?
Lovable stops and shows question cards before it writes any code. The July landing page prompt predates the line and drew none; every run since has.
| Prompt | Questions first | Credits |
|---|---|---|
| Landing page + email opt-in | 0 | 1.8 |
| Empty states and skeletons | 2 | 9.5 |
| SaaS MVP with user auth | 4 | 10.4 |
| Six-section SaaS landing page | 5 | 4.5 |


Every answer replaces a guess I would otherwise pay to correct in a second round. Lovable's best-practices page gives the line word for word, and the library prompts add one instruction to it: save the answers to project knowledge, which holds 10,000 characters that Lovable reads on every later prompt.
Lovable's advice, then and now
Is the CLEAR framework still Lovable's prompting advice?
No. CLEAR sat in Lovable's prompting docs in July 2025 and was gone from the same page by April 2026. The current page teaches four phases and opens with the question line.
| Source | When | Structure taught | Questions first |
|---|---|---|---|
| The Lovable Prompting BibleLovable blog | Published 16 Jan 2025 | Four levels: Training Wheels (Context, Task, Guidelines, Constraints), No Training Wheels, Meta Prompting, Reverse Meta Prompting | No |
| The C.L.E.A.R. frameworkLovable docs, Prompting best practices | Archived 3 Jul 2025; gone by 1 Apr 2026 | Concise, Logical, Explicit, Adaptive, Reflective, used as a checklist | No |
| Prompting best practices, currentLovable docs | Read 23 October 2026 | Four phases: lay the foundation, think in systems, build with precision, iterate and ship | Yes, the first section on the page |
| Library prompts on this sitelovable-prompts.com | Since 26 Sep 2026 | Eight sections, from Context to Before Building, with a growth channel | Yes, the closing section of every base prompt |
CLEAR still reads well as a checklist for a single sentence. It says nothing about the order to build in or about asking Lovable for its questions, the two sections the current docs and the library prompts both carry. The Prompting Bible's Training Wheels skeleton (Context, Task, Guidelines, Constraints) is the ancestor of the first and last sections above. The four current phases, each with a prompt line, are on the prompt examples page.
After the first prompt
How do you keep prompting without paying for rework?
One foundation prompt, then one change at a time. Each step priced from Lovable's docs and my runs.
- 01
One structured Build prompt
Usage-based
Our foundations cost 1.8 to 10.4 credits.
- 02
Answer the question cards
Part of the same message
Answers go into project knowledge, so later prompts inherit them.
- 03
One change per prompt
Usage-based, smaller
Name the component, say what stays. The docs: many requests cost less than one credit.
- 04
Describe the miss, never the feature
Usage-based
Restating the whole feature regenerates it and risks the parts that worked.
- 05
Plan mode after two misses
1 credit plus research
Plan never touches code until you approve the plan.
A change prompt needs three things: what to change, where it is, and what stays as it is. Lovable's debugging guide adds the rule for bugs: describe the bug, the steps and what you expected, and move to Plan mode when a fix keeps missing. Where each mode lives and what every action costs is in the app builder guide; the mistakes that cost the most credits are in common Lovable mistakes.
The section other guides leave out
Why does a Lovable prompt name a growth channel?
Because the channel decides what the app has to contain. A product found through search needs server-rendered pages; one that spreads by invite needs the invite loop in the first build.
| Channel | What the prompt asks Lovable to build |
|---|---|
| Organic SEO / AI search | Server-render every public page with one H1, a unique title and meta description, clean URLs and a sitemap.xml, so search engines and AI answers can read it. |
| Product-led growth | Add an invite flow inside the app and a share link on the main object, and show the first result before sign-up asks for anything. |
| Paid search | One landing page per ad group with the keyword in the H1, a single call to action above the fold, and UTM parameters stored with each sign-up. |
| Social and short video | Give every shareable page its own Open Graph title and image, and a public URL for each result a user can post. |
| Store each sign-up with its consent text and a timestamp, and send a welcome email on sign-up. | |
| B2B sales | Add a demo request form asking for company size and role, and a pricing page with a contact sales path. |
Where this comes from
Brian Balfour's Four Fits put product-channel fit beside product-market fit. Building eight MVPs in eight weeks showed me that distribution was the bottleneck, so every prompt here picks the channel before the features. Product-channel fit, applied to prompts.
The prompting handbook
The channel-first workflow as a document: the four-step workflow (channel, distribution surface, core value, feedback loop), a design table per channel, worked prompt examples and a 7-day checklist. Free with an account.
Start from a prompt that already has all eight
122 library prompts in this structure, each tagged with its growth channel. Free to copy.
Frequently asked
What is the CLEAR framework for Lovable prompts?
Concise, Logical, Explicit, Adaptive, Reflective: a checklist Lovable's prompting docs used in 2025, visible in the Wayback Machine copy of the page from 3 July 2025. It was gone by the 1 April 2026 copy, and the page read on 23 October 2026 teaches four phases instead, opening with asking Lovable for its questions. The five words still hold; the current advice adds the order to build in.
Is there an official Lovable prompting guide?
Two. The Prompting best practices page in Lovable's docs, organised in four phases, and the Lovable Prompting Bible, a blog post published on 16 January 2025 that teaches four levels from Training Wheels to Reverse Meta Prompting. The docs page is the one Lovable keeps current; the Bible still talks about the Knowledge Base in project settings and a default mode, both older names.
Should I write one long prompt or many small ones?
One structured prompt for the foundation, then one change per prompt. The foundation prompt carries the order and the rules, so the first build has something to stand on; after that, Lovable's best-practices page asks you to say what to change and what to leave alone, which a single-change prompt does by default.
What goes in project knowledge instead of the prompt?
Anything every later prompt should obey: the audience, the roles, naming, the design rules. Project knowledge and workspace knowledge hold up to 10,000 characters each, project knowledge wins on conflict, and a root AGENTS.md in the code is always read. The prompt carries the task in front of you.
Can ChatGPT or Claude write my Lovable prompt?
Yes, and the Prompting Bible calls it Meta Prompting: ask another model to rewrite your prompt to be more concise and detailed. The catch is the structure. A general chatbot returns a feature list; Lovable builds better from numbered features, named states, a build order and a closing question line, which is what the builder on this page assembles.
Do these prompting rules work in Bolt or v0?
The structure transfers; the meters differ. Bolt meters tokens that grow with the codebase and v0 meters credits per model, so a scoped prompt saves on all three. The question cards are a Lovable behaviour our runs recorded; I have not run Bolt or v0 with these prompts.
What we did not publish
- A run of a prompt the builder assembled. The builder follows the library structure; it has no run of its own yet.
- The same app prompted with and without the question line on the same day. The table compares different prompts.
- The exact date CLEAR left the docs. The archive shows it on 3 July 2025 and not on 1 April 2026.
- Runs in Bolt or v0.
Sources
- Lovable docs: Prompting best practices, read 23 October 2026
- The same page, Wayback Machine copy of 3 July 2025 (the C.L.E.A.R. section)
- Lovable docs: Debug and improve your app
- Lovable docs: Knowledge
- Lovable docs: Plan mode
- Lovable blog: The Lovable Prompting Bible, published 16 January 2025
- My runs: 31 Jul 2026, 26 Sept 2026, 26 Sept 2026, and the SaaS landing page on 26 September 2026
Written by

Marco Kohns
Founder of ProtoBites - Venture Growth Studio
Growth PM at a Silicon Valley scale-up (a16z and General Catalyst backed), ex-Techstars where he consulted 13 early-stage startups, Reforge-trained. Every prompt on this site comes out of shipping ProtoBites' own portfolio products.
Related reading
- every Lovable guide, by build stage · Choose a tool, plan, prompt, build safely, launch.
- Lovable prompt examples with their output · Three runs, screenshots, credits.
- advanced Lovable prompting · Skills, goals, Plan mode, chains.
- the eight priced mistakes · Before-and-after prompts for each.
- the app builder interface · Where the modes and the toolbar live.
- the landing page prompt annotated above, in the library · Eleven pages by traffic source.
- UI prompts · The states system, run and measured.
- when Cursor is the better tool · Editor versus builder.
- the landing page build kit · The annotated prompt with its schema and queries.
- Lovable SEO · What the platform fixes and what the prompt has to.
- from idea to app, measured · Where the prompt sits in the whole path.
- vibe coding prompts · The skeleton in ten short prompts, channel included.
- Lovable and Supabase · Where the Safe-Guard lines come from.
- SaaS landing page prompt · The house shape applied to a SaaS landing page, with the run.
- launching on Product Hunt · Four launch-day prompts in the house shape.
- what is vibe coding · Why a brief beats a vibe: eleven questions asked across six runs.
- Lovable prompt generator · Writes a structured prompt for an idea that matches no library entry.