Updated 8 examples · 3 run in Lovable

    Lovable prompt examples: before and after, with what they built

    8 weak prompts rewritten into ones Lovable builds right the first time, 3 of them measured in credits. Then check your own prompt against the same seven rules before you spend credits on it.

    By Marco Kohns · Every measured example was run in our own Lovable workspace

    Check your prompt

    Try:13 words

    Runs in your browser. Nothing is sent or saved.

    1/7Expect rework
    • Who it is for found

    • Named components missing

      Add: Name parts: table, card, modal, form, chart.

    • Empty, loading, error states missing

      Add: Show an empty state, a loading skeleton and a retryable error.

    • Visual direction missing

      Add: [Heading font], [body font], [2 colours], 8 px spacing.

    • Guardrails missing

      Add: Do not change [what must stay]. Only edit [where].

    • Questions first missing

      Add: Before building, ask me up to 3 questions. Wait for answers.

    • No vague adjectives missing

      Add: Replace modern or sleek with concrete fonts, spacing and components.

    Examples

    Eight prompts, before and after

    Show:
    Build newRun · 10.4 credits

    SaaS MVP with user auth

    AfterContext: a workspace tool for [a small team adopting it together]. Core: sign-up, a workspace on first sign-in, invite a teammate by tokenised link, roles read from the database on every request. States: empty member list, pending invite, expired invite. Before building: ask me any questions you need.

    Why it works: Lovable asked 4 questions (audience, workspace naming, invite delivery, look), then built and tested the invite flow itself as a second user.

    Open this prompt page →
    Build newRun · 1.8 credits

    Landing page + email opt-in

    AfterOne job: get [audience] to leave their email for [offer], arriving from [one traffic source]. One field, one button, stored in an insert-only table with UTM columns, duplicate-safe. Inline success state. Three FAQs. Proof elements are placeholders, never invented.

    Why it works: All five features came back in one round. Lovable also invented a brand name for the page, which is why the prompt scopes proof to placeholders: name yours.

    Open this prompt page →
    Build newRun · 9.5 credits

    Empty states & skeletons

    AfterDefine empty (first-use and cleared), loading (skeleton past 220 ms), error (retryable, or with a reference id) and partial-data states as shared components, plus a /states gallery that renders every variant.

    Why it works: Lovable asked 2 questions, built 4 base components and a gallery, then tested slow loading, failure and retry itself.

    UI prompts, with the gallery screenshots →
    Build newNot run yet

    Table with sorting & filters

    AfterServer-side sorting and filtering. Keep sort, filters and page in the URL. An empty result state with a Clear filters action. Row virtualisation past [n] rows.

    Why it works: Naming server-side and URL state stops Lovable from loading every row into the browser, and makes the view shareable and back-button-safe.

    The table prompt →
    ChangeLovable docs

    Change one thing

    AfterOn the orders page only, replace the status text with coloured badges. Do not change the table, the filters or any other page.

    Why it works: What to build, where it goes and what must stay untouched: the three parts Lovable's prompting guide asks for in a change prompt.

    Common mistakes →
    StyleLovable docs

    Set the look once

    AfterHeadings [font] 600, body [font] 16/24. Colours [ink] and [accent]. 8 px spacing, 12 px radius, no gradients. Save these to project knowledge.

    Why it works: Concrete values replace adjectives the model cannot act on, and a committed visual direction skips Lovable's design questions. Project knowledge keeps later sections consistent.

    UI prompts →
    FixOur pattern

    When Lovable guessed wrong

    AfterThe invite email never arrives. Expected: an email within a minute. Check the send step and show me the log. Do not change the invite UI. If the cause is unclear after one attempt, switch to Plan mode.

    Why it works: Expected versus actual, where to look, and a guardrail. A vague fix request costs a build message each time; a Plan mode message costs 1 credit and changes nothing until approved.

    Common mistakes →
    BackendOur pattern

    Ask for security up front

    AfterStore [data] per user. Turn on row-level security so each user can only read and write their own rows. Never accept a user id from the client on a write. Show me the policies.

    Why it works: Missing row-level security is the flaw behind CVE-2025-48757 in Lovable projects. The docs say Lovable sets up access rules for features that store user data; the prompt makes the rule explicit so the generated policy is the one you meant.

    Backend prompts →
    SaaS MVP with user auth
    Before: Build a SaaS app with login and teams. After: Context: a workspace tool for [a small team adopting it together]. Core: sign-up, a workspace on first sign-in, invite a teammate by tokenised link, roles read from the database on every request. States: empty member list, pending invite, expired invite. Before building: ask me any questions you need.
    Landing page + email opt-in
    Before: Make a landing page for my product. After: One job: get [audience] to leave their email for [offer], arriving from [one traffic source]. One field, one button, stored in an insert-only table with UTM columns, duplicate-safe. Inline success state. Three FAQs. Proof elements are placeholders, never invented.
    Empty states & skeletons
    Before: Add loading spinners. After: Define empty (first-use and cleared), loading (skeleton past 220 ms), error (retryable, or with a reference id) and partial-data states as shared components, plus a /states gallery that renders every variant.
    Table with sorting & filters
    Before: Show my data in a table. After: Server-side sorting and filtering. Keep sort, filters and page in the URL. An empty result state with a Clear filters action. Row virtualisation past [n] rows.
    Change one thing
    Before: Make the orders page better. After: On the orders page only, replace the status text with coloured badges. Do not change the table, the filters or any other page.
    Set the look once
    Before: Make it look modern and sleek. After: Headings [font] 600, body [font] 16/24. Colours [ink] and [accent]. 8 px spacing, 12 px radius, no gradients. Save these to project knowledge.
    When Lovable guessed wrong
    Before: This is wrong, fix it. After: The invite email never arrives. Expected: an email within a minute. Check the send step and show me the log. Do not change the invite UI. If the cause is unclear after one attempt, switch to Plan mode.
    Ask for security up front
    Before: Add a database. After: Store [data] per user. Turn on row-level security so each user can only read and write their own rows. Never accept a user id from the client on a write. Show me the policies.

    Measured runs

    What the three measured prompts built

    Pasted unedited into fresh projects in our own workspace, credits read from the balance before and after. One screenshot per run; the full sets are on the prompt and category pages.

    The landing page Lovable generated from the prompt: a hero with the offer in one sentence, an email form above the fold, and consent text under the submit button
    Landing page + email opt-in, 31 Jul 2026: one round, 1.8 credits, all five priority features. Lovable invented a brand name for the page, which is why the prompt scopes proof to placeholders.
    The full run and the builder →
    The generated SaaS landing page in Lovable's preview: a Cadence wordmark, a headline reading One shared calendar for everything your team is about to publish, a Create your workspace button and three feature cards for shared plan, invite in seconds and clear permissions
    SaaS MVP with user auth, 26 Sept 2026: 4 questions first, 10.4 credits, the invite flow tested by Lovable as a second user, roles read back as checked in the database.
    The full run and the builder →
    The Error section of the generated states gallery: a retryable card reading Tasks could not be loaded with a Try again button, a non-retryable card reading This request could not be completed with Reference ID FW-2048, and a compact form failure card
    Empty states & skeletons, 26 Sept 2026: 2 questions first, 9.5 credits, a /states gallery with retryable and non-retryable errors kept apart, as the State Rules section asked.
    The gallery screenshots and the run →

    How long should a prompt be?

    Our build prompts run 298 to 550 words

    Long enough to name screens, states and guardrails. Short enough to read before you paste. Change prompts are far shorter: one change, where, and what stays.

    Word counts: the change example on this page and the shortest, median and longest base prompt across the 122 library prompts, computed at build time
    Change prompt (the example above)23
    Shortest build prompt298
    Median build prompt541
    Longest build prompt550

    Word counts across the 122 base prompts in the library, computed at build time. The change prompt is the Change one thing example above.

    Lovable's own advice, applied

    Four phases, and the prompt for each

    01

    Lay the foundation

    Product, audience, why they use it, the key action. Then the look.

    Before building, ask me up to 3 questions about who uses this and what they do first.
    02

    Think in systems

    Shared states, dialogs and navigation before screens.

    Create shared empty, loading and error components. Every screen must use them.
    03

    Build with precision

    One component at a time, named parts, final copy.

    Add a pricing section with 3 cards: [plan], [price], [3 features]. Nothing else.
    04

    Iterate and ship

    One change per message. Keep what works.

    On the settings page only, move Delete account into a confirm dialog. Change nothing else.

    Phase names from Lovable docs, Prompting best practices, read 22 October 2026. The example lines are ours.

    Skip writing them yourself

    Every library prompt carries all seven rules. Free to copy, 122 of them.

    Frequently asked

    What does a good Lovable prompt include?

    Who it is for, named components, the empty, loading and error states, a visual direction, guardrails, and a request to ask questions first, with no adjectives the model cannot act on. The checker above tests for those seven, and every library prompt carries them.

    How many credits does a prompt cost?

    Lovable publishes no per-prompt figure; Build mode is billed on the work done. Our measured runs on library prompts cost 1.8 credits for a landing page, 9.5 for a states system and 10.4 for a SaaS foundation with auth, read from our own balance before and after. Lovable's illustrative example for a small style change is 0.50.

    Should I build a whole app in one prompt?

    Lovable's guide says a full-page prompt gets you noise and a section-based prompt gets you signal. Build the frame and the shared states first, then one screen at a time. The library prompts are one message each but carry a build order, which is what makes one paste behave like a sequence.

    Can I copy these examples into Lovable?

    The three measured ones are abridged here; copy the full prompt from its page, replace the bracketed parts, and paste. The other five are patterns to adapt. Leave a bracket in and Lovable invents what goes there.

    Why ask Lovable to ask questions first?

    It fills the gaps with your answers instead of guesses and saves them to project knowledge for later prompts. In our runs the closing line produced 0 questions (before the line existed), then 2, then 4, each costing nothing extra.

    What we have not tested yet

    • The five pattern examples. They follow the docs and our runs; none has its own measured run.
    • A weak prompt and its rewrite on the same app, side by side, with both credit figures.
    • The checker against prompts that passed in Lovable: it tests for the seven sections, never for the outcome.

    Sources

    1. Lovable docs: Prompting best practices
    2. Lovable docs: Design guidance
    3. Lovable docs: Plan mode
    4. Lovable docs: Credits and usage
    5. Our runs: 31 Jul 2026, 26 Sept 2026, 26 Sept 2026

    Docs read 22 October 2026.

    Written by

    Marco Kohns

    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.