Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.lovable.dev/llms.txt

Use this file to discover all available pages before exploring further.

This guide helps all users—new or experienced—get up to speed quickly and avoid common pitfalls when building on Lovable.

​
1. Set your foundation: Use the knowledge file

Why it matters: The Knowledge file is your project’s brain. It gets sent with every prompt and helps the AI understand the full context. What to include:
  • Your product vision (think of it like a PRD)
  • User journeys and personas
  • Key features and functionality
  • Design systems and UI guidance
  • Role-specific behavior (e.g. Admin, User, Investor)
You can auto-generate a Knowledge file via Plan mode:
Generate knowledge for my project at T=0 based on the features I’ve already implemented.

​
2. Prompting Best practices

Clear, verbose prompts = better output. Think of the AI like your engineering partner—it only knows what you tell it. Prompting tips:
  • Be specific: Mention the exact page (e.g. /dashboard) and expected behavior.
  • Use natural language 
    I want users with the role Investor to access this component, but not Admins.
  • Add screenshots: Especially useful for describing bugs or UX issues.
  • Add guardrails: Tell the AI what not to touch. E.g. 
    Do not edit /shared/Layout.tsx.
  • Repeat important instructions across prompts. The AI’s memory can be limiting.
  • Avoid trying to implement 5 things at once. Break work into smaller, testable chunks. Use Plan mode between each block to validate before moving on. 
    **Feature Breakdown Template:**
Create the new page
Add UI layout
Connect the data
Add logic + edge cases
Test per role
  • If your app has multiple roles (e.g. Admin, Investor, Startup), always define which role the prompt applies to. This helps avoid bugs caused by shared logic/components. 
    As an Investor, I want to view the company dashboard, but I shouldn’t be able to edit it. Please isolate this feature to the Investor role only.

​
3. Use Plan mode early and often

Plan mode = your AI co-pilot. It helps you debug, brainstorm, and plan implementations—without editing your code until you’re ready. When to switch to Plan mode:
  • After 2–3 failed “Try to Fix” attempts
  • When debugging complex logic or database issues
  • When planning new features 
    Suggest 3 ways to implement X
Workflow tip:Some users like to use Plan mode for 60–70% of your time. Only click “Implement the plan” when you’re fully satisfied.
If you forget using the Plan mode, this format improves output consistency and prevents collateral edits.
On page /settings, implement [feature]. The expected behavior is [XYZ]. Please don’t touch component A, layout B, or shared logic unless necessary. Follow best practices from Tailwind / Supabase / X.
To avoid unwanted code execution:
Investigate but don’t write code yet.

Suggest 3 ways to solve this without changing anything.
This keeps control in your hands.
When AI enters a “loop,” use this sequence to avoid endless cycles of patching broken code:
  1. Switch to Plan mode
  2. Paste the error screenshot
  3. Say: 
    Please investigate this without breaking other features. If needed, revert to the last working version and fix from there.

​
4. Avoid common pitfalls with Supabase

Heads-up: Supabase does not revert cleanly. If you revert a version, your database schema may break. Best practices:
  • Connect Supabase after front-end is stable
  • If you must revert, prompt the AI: 
    Please validate the SQL schema at T=0 and ensure no breaking changes have occurred.
  • Always test database-linked features before publishing

​
5. Use Visual Edit for quick UI fixes

The Visual Edit tool is free and fast. Use it instead of prompts for:
  • Changing text, colors, fonts, layout tweaks
  • Editing multiple small elements at once
  • Safe, credit-free commits (with undo available)

​
6. Use GitHub + version control wisely

  • Every edit is a commit. Use pinning to mark stable versions. After every working feature: Pin it
  • After every bug: Compare versions visually. You can prompt with: 
    Compare version at T–1 to T–0. What changed? What might be breaking?
  • Come back to a stable version if you feel the AI has broken too much things.
  • Use GitHub branching at your own risk. Avoid deleting branches before switching back to main in Lovable to prevent project sync issues.

​
7. When all else fails, remix

Many users realize: doing it all over takes less time the second time.
  • Remix creates a clean copy of your project at T=0.
  • Rebuild with better prompting + clearer knowledge
  • Use your old project as reference only
Use cases:
  • You’re stuck in a buggy loop
  • You want to restart clean with preserved history
  • You need to disconnect Supabase and try a new path
Remixing requires disconnecting Supabase first.

​
8. Stay patient, stay calm

You’re not alone. AI can be magical one moment and frustrating the next. The final 5% of any build is often the slowest—but the most important.
Golden rule:Take your time with prompts. Re-check everything. Break work into small, testable blocks. The more precise your inputs, the better your outputs.

​
9. Use the docs and ask for help

  • Documentation contains walkthroughs, templates, SEO tips, integrations, and more. You can ask questions directly in the doc AI assistant.
  • Join the Discord community for peer support.

​
10. Bonus tips

  • Add a voice note prompt using dictation (e.g. On Mac, use the mic to dictate long prompts) for long prompts. You’ll craft better input faster—especially useful when frustrated or tired.
  • Use the “I am frustrated…” prompt pattern to nudge better AI focus
  • After a major edit, always recheck multiple roles and their behavior (especially with conditional logic)
  • Store stable versions as fallbacks for quick debugging
  • If you’re seeing unexpected side effects, this helps avoid bugs caused by overly generic logic. 
    Create a component specifically for [role X] and do not reuse shared components unless clearly scoped.