Lovable PromptsLovable Prompts

    Learn Lovable AI

    Lovable will build almost anything you describe. The difference between a demo and something people use is what the prompt specifies: priority, build order, the states nobody asks for, and how anyone is meant to find the result.

    Learn Lovable AI hero: the hub title beside a card listing the four guide groups, prompting, the platform, comparisons and growth, with the guides in each

    Three of the library's prompts have been run in Lovable and measured, with screenshots and credits on the guides below. These guides cover the rest, in the order it matters. If you would rather start from a working prompt, the Lovable prompts library has 151 of them across 11 categories.

    Prompting Lovable

    Structure, patterns and the mistakes that cost the most rebuild time.

    Beginner
    15 min read

    How to Write Prompts for Lovable AI: The Prompting Guide

    The structure Lovable responds to, its cost model from its own docs, a library prompt annotated line by line, and three prompts we pasted in and measured.

    Intermediate
    15 min read

    Lovable Prompt Examples: 3 Library Prompts and What They Built

    Three library prompts annotated line by line, and what came back when we pasted them in: screenshots, the questions Lovable asked, the credits each run cost.

    Advanced
    10 min read

    Advanced Lovable Prompting: Skills, Goals and Prompt Chains

    Skills, goal runs, Plan and Chat modes, project and file references, the debugging order and meta prompting, quoted from Lovable's docs, plus the library's chained refinement prompts.

    Beginner
    10 min read

    Lovable App Builder Guide: Editor, Modes and Prompt to App

    A tour of the editor from our own sessions: the chat panel and its three modes, the preview toolbar, the code view, history and Cloud, each quoted from Lovable's docs.

    Beginner
    10 min read

    8 Common Lovable Mistakes, Priced, One With a CVE

    The eight mistakes that cost Lovable builders the most, each priced in correction rounds, with the exact prompt line that prevents it.

    Beginner
    11 min read

    Vibe Coding Prompts: Ten With the Distribution Step Built In, and the Runs Behind Them

    Ten copy-paste vibe coding prompts that each name the channel the app will be found through and the surface it needs, the definition from its source, and two prompts tied to measured Lovable runs.

    Intermediate
    10 min read

    Prompt Engineering Examples: Before-and-After Pairs From a Library We Rewrote, With the Outputs

    Six before-and-after pairs from the audit of this site's prompt library: the line added, read from the prompt at build time, the vendor rule it applies quoted from Anthropic's and Lovable's docs, and the measured effect where a run exists.

    Distribution and growth

    Choosing a channel before you build, and getting the first users after.

    Beginner
    6 min read

    How to Get Your First 100 Users for Indie Hacker Projects

    Pick one channel, build for it, run the matching playbook. With a cited case study and the directory list that verifiably gives links.

    Intermediate
    7 min read

    Product-Channel Fit: Why the Channel Shapes the App You Prompt

    Brian Balfour's product-channel fit applied to Lovable: pick the channel before the first prompt, because the channel decides the features.

    Beginner
    3 min read

    The Lovable Prompting Handbook

    A single reference for prompt structure, the distribution-first workflow, and the mistakes that cost the most rebuild time.

    Beginner
    11 min read

    Idea to App: The Path We Measured, From Prompt to First Users

    Brief, prompt, build measured in credits across three runs, the questions the builder asked, publishing, and the step the agency guides skip: the channel before the prompt.

    Beginner
    15 min read

    50 App Ideas With the Build Prompt and the Channel That Gets Each One Its First Users

    Fifty app ideas read from the prompt library at build time, each with the prompt that builds it and the distribution channel it was written for, grouped by channel, ranked by upvotes, three of them run with credits counted.

    Beginner
    10 min read

    SaaS Landing Page Prompt: The Section Spec, Run in Lovable, With the Page It Built

    Six sections in the order a cold visitor reads them, one CTA, pricing from one config object and FAQ schema, as a prompt; run in Lovable the day of writing with credits counted and the output checked against the spec.

    Beginner
    13 min read

    15 SaaS Ideas With the Product Prompt, the Billing Mechanics and the Channel for Each

    Fifteen SaaS ideas composed from the prompt library: the product prompt, the mechanics prompts that make it chargeable, a billing model that follows from who pays, and the channel. One foundation run at 10.4 credits; no market-size guesses.

    Beginner
    11 min read

    15 AI App Ideas With the Prompt, the Grounding Rule and What the AI Calls Cost on Lovable

    Fifteen AI app ideas read from the prompt library, each with the safeguard line its prompt carries and its channel; Lovable's AI connector rules read today (no API keys, a 4-credit monthly grant, 429 limits); and the counts from the one AI app this site runs.

    Beginner
    8 min read

    Product Hunt Launch: The Rules From Product Hunt Itself, the Pages to Build First, and Why We Have Not Launched

    Product Hunt's own launch rules quoted, third-party results with their sources kept visible, the four launch-day pages the library builds, and the plain statement that this site has not launched.

    Beginner
    9 min read

    How to Build an MVP: One SaaS From Prompt to Landing Page in a Day, Every Credit Counted

    One measured build: a SaaS foundation, SEO review, security scan, installable build and landing page on Lovable in a day, each step a prompt with its credits read from the billing page, ending with what is still missing before a first user.

    Beginner
    8 min read

    MVP Examples You Can Inspect: Four Built Here With Prompt, Cost and Output, and the Famous Three Traced to a Source

    Four MVP examples built on Lovable from this site's prompts, each with the prompt, the credits and the output; and Airbnb, Dropbox and Zappos traced to the best readable source, with the unsourced one labelled.

    Intermediate
    8 min read

    Build a SaaS on Lovable: The Foundation Prompt, the Schema That Proves Its Policies, and the Billing Step

    The order that avoids rework: the foundation prompt run for 10.4 credits, the SaaS starter kit's schema with its policies and verification checks counted from the files, the mechanics prompts, and billing last with the webhook as the only writer.

    The Lovable platform

    Pricing, credits and how the product actually works.

    Beginner
    10 min read

    How Lovable Credits Work (And How to Burn Fewer)

    What Lovable credits are spent on, how rollover and expiry actually interact, which credits are consumed first, and the prompt habits that cut credit burn.

    Intermediate
    11 min read

    Lovable SEO: What Pre-rendering Fixes, and What Our Own Migration Measured

    Lovable's SSR and pre-rendering from the docs, Google's rules on JavaScript, and the Search Console numbers from both sides of our own move from a Lovable build to server-rendered pages at the same URLs.

    Beginner
    10 min read

    Vibe Coding Tips From One Site's Git Log: Twelve Mistakes and the Commits That Fixed Them

    Twelve mistakes this site made building and running with AI tools, each with the date, the fixing commit and the lesson, the checks that came out of them, and the public record on AI-written code.

    Beginner
    10 min read

    Lovable Pricing in 2026: Plans as Printed Today, and What One Prompt Costs in Credits

    Lite, Pro, Business and the full Pro credit ladder read from the pricing page on the printed date, the Free plan's grants, the credit rules from the docs, and what three prompts cost in our own measured runs.

    Intermediate
    9 min read

    Lovable and Supabase: What Cloud Provisions, Where RLS Breaks, and Four Schemas That Passed

    Lovable Cloud on Supabase's foundation versus your own project, from the docs; the three ways row-level security fails in a generated app, per the CVE and the docs; and the four kit schemas with policies executed and proven.

    Intermediate
    12 min read

    Lovable Security: The CVE, the Two Scans, and the Checks We Ran on Our Own Kits

    CVE-2025-48757 with its score and the researcher's 303-endpoint scan; Lovable's Quick and Deep scans from the docs; a Deep scan run on our test project; the four kit schemas' policies; and this site's own paywall leak, with the check that fixed it.

    Intermediate
    13 min read

    Lovable and Stripe: Built-In Payments, Your Own Account, and the Webhook Behind Our Own Checkout

    Built-in payments against your own Stripe account from the docs; Stripe's fees read today with the cost of one sale; Stripe's fulfilment rule; and the webhook, claim route and four defects behind the checkout that sells our bundle.

    Beginner
    10 min read

    Lovable Mobile App: What the Phone App Does, and How to Put Your Own Lovable App on a Phone

    What the Lovable iOS and Android app can and cannot do, from the docs and the store listing; the two documented ways to ship a Lovable-built app to a phone, PWA or Capacitor; and the PWA prompt run on our own project, credits counted.

    Beginner
    16 min read

    What Is Vibe Coding? The Definition, the Record, and What It Cost Us

    The three definitions with their dates, the public record with sample sizes, six measured Lovable runs with credits and questions asked, and the line between vibe coding and AI-assisted development.

    Beginner
    16 min read

    What Is an AI App Builder? How They Work and What Six Runs Produced

    The category from the outside: the vendors' definitions, how a prompt becomes an app with a backend, six measured runs with credits and questions asked, the five types and who each suits, what the vendor pages leave out, and seven limits with their sources.

    Lovable compared

    Where Lovable wins, where it does not, and what to use instead.

    Beginner
    15 min read

    Lovable Alternatives: 6 Options Compared Honestly

    Bolt, v0, Replit, Cursor, Base44 and Bubble compared against Lovable on category, pricing model, code ownership and documented weaknesses. Includes the case for not switching.

    Beginner
    5 min read

    Lovable vs Cursor: Not the Same Category

    Cursor ships no database, auth or hosting, and Lovable cannot import an existing repository. Both facts decide this comparison before price enters it.

    Beginner
    6 min read

    Lovable vs Replit: IDE or Builder

    The closest match to Lovable on capability. Compared on whether you want an IDE around the agent, how effort-based billing differs from credits, and a documented production incident.

    Beginner
    6 min read

    Lovable vs Bolt.new: What the Meter Counts

    Same category, so the differences are billing and exit. Bolt's tokens scale with codebase size by its own docs, against Lovable's two-way GitHub sync.

    Beginner
    16 min read

    Replit Alternatives: Six Tools Sorted by the Job You Used Replit For

    Six alternatives sorted by whether Replit was your agent builder, cloud IDE or pipeline step, prices read on the vendor pages on the date shown, Replit's own effort-based pricing posts quoted, our measured Lovable runs, and how to move a Repl out.

    Intermediate
    10 min read

    Cursor vs Claude Code: Editor or Agent, Priced and Measured on One Day's Work

    Both vendors' definitions and prices read the same day, Anthropic's published cost per developer, one day of Claude Code on this repository counted from git, what each does that the other cannot, and how to run both.

    Beginner
    11 min read

    AI Coding Tools in 2026: Eight Compared by Job, Three We Run and Measured

    Builders, editors with an agent and terminal agents: eight tools with prices and meters read on the vendor pages the same day, JetBrains' 2026 adoption survey from source, and measured runs on the three we use.

    Beginner
    11 min read

    Base44 Alternatives: Six Builders Sorted by What You Own After You Leave

    Base44's plans and GitHub sync rules quoted from its own pages on the check date, six alternatives sorted by what leaves with you, prices read the same day, and measured Lovable runs.

    Beginner
    9 min read

    Best AI App Builder in 2026: Six Builders Compared on What Ships, Priced the Same Day

    Lovable, Bolt.new, v0, Base44, Replit and Bubble compared on backend, code out and meter, prices read the same day, measured Lovable runs with screenshots, and a disclosure of which one we run and sell.

    Beginner
    11 min read

    Lovable vs v0: Same Category Now, Different Stack, Meter and Exit

    v0 builds full-stack now, by its own docs. What still differs: Next.js on Vercel versus a React app on Lovable Cloud, per-user dollar credits versus seat-free credits, and v0's repo import against Lovable's export-only sync. Prices read today; only Lovable run by us.

    Beginner
    11 min read

    Bolt vs Cursor: A Builder With a Backend, or an Editor for the Repo You Already Have

    Not the same product. Bolt is a browser builder with a database, hosting and tokens that grow with the project; Cursor is an editor with an agent and no backend. Prices and meters read today, the Bolt-to-Cursor handoff from Bolt's docs, and 498 measured Cursor rules files.

    Claude Code and other AI tools

    The coding agents builders run beside Lovable, from our own workspace.

    Intermediate
    11 min read

    Claude Code Commands: Built-ins, Skills and the Ones We Run

    Built-in commands from the docs, a minimal SKILL.md that works, the 24 custom commands running in our workspace by family, what broke, and when a subagent is the better tool.

    Intermediate
    15 min read

    Cursor Rules: How .mdc Files Work, Three to Copy, and What 498 Public Rules Show

    The four rule types and the .mdc frontmatter from Cursor's docs, three rule files written for a Lovable export, 498 public rules measured against the 500-line guidance, and the ETH Zurich result on whether context files help.

    Intermediate
    14 min read

    Claude Code Subagents: The Config, Two We Run, and What 161 Public Agents Show

    The built-ins and every frontmatter field from the docs, two subagents checked into our repository with a measured first run, and 161 public agents measured against the 15,000-token description warning.

    Beginner
    11 min read

    Coding Prompts for ChatGPT, Claude and Copilot: Ten That Ship, and the Rules Behind Them

    Ten copy-paste coding prompts derived from OpenAI's, Anthropic's and GitHub Copilot's own prompting guides, what a library of 101 prompts built to that spec looks like, and where each prompt should live so it runs without pasting.

    Intermediate
    10 min read

    The CLAUDE.md File: What Goes In, What the Docs Say, and What Broke in 29 of Ours

    Where CLAUDE.md loads from and the 200-line guidance from the docs, the ETH Zurich study on context files, 29 files in one studio counted by length, this site's own file, and the four ways ours broke.

    Intermediate
    11 min read

    Cursorrules Examples: Six Rule Files by Framework, Written Against What 498 Public Ones Do

    Six .mdc rule files for Next.js, React and Vite, Supabase, Tailwind and shadcn/ui, Node APIs and Python, each with its attachment mode and the reason per line, plus what 498 public rule files target and how they attach.

    Beginner
    15 min read

    Claude Code Tutorial: Install to a Shipped Change on One Site, Counted from Git

    Seven steps with an artefact each: the install, a timed first question, CLAUDE.md, plan mode for a twelve-file change, seven checks before a push, the commit, a skill and a subagent, and one day's output from git.

    Also on this site

    Start building

    Prompt Library

    Browse 151 ready-to-use prompts, each tied to a growth channel

    Prompt Generator

    Describe your app, get a structured prompt with a distribution section

    Landing Page Prompts

    Pages built around a traffic source rather than a layout