Skip to content
K Koda Intelligence
Subscribe
All Dojos
AI Foundations Claude Code Cowork M365 Copilot NotebookLM ChatGPT Lovable Perplexity
Discipline 06 · 4 white, 6 brown, 5 black

Lovable Dojo

Turn plain English into a deployed app with auth, data and payments. The capstone is a live SaaS on your own domain.

Your rank

Untied

15 modules · 173 prompts · 82 sourced
White · 4 modulesBrown · 6 modulesBlack · 5 modules
White Belt4 modules42 promptsNot started
Brown Belt6 modules86 promptsNot started
Black Belt5 modules45 promptsNot started
Version 2.0.9·Revised 2026-09-13·Refreshed weekly·52 sources cited
Inventory
Modules15
Prompts173
Prompts sourced82
Sources cited52
Your session
Modules woven0
Prompts ticked0
Minutes trained (est)0
Start training
// 01 / The ladder

Fifteen modules

White belt is a live one-page site with a working form. Black belt is a paywalled app on your own domain.

White Belt
Fundamentals
Not started
01Up next
What Lovable Is: Vibe Coding and the Three Ways to Build
Understand what Lovable actually does, turning plain-English prompts into real, deployable full-stack apps, and the three ways you drive it: Build mode, Plan mode, and the preview toolbar.
~45 min (est)14 prompts 12 beginner · 2 intermediate
02
Your First Build Loop: Prompt, Preview, Iterate
Learn the core rhythm of building in Lovable: make one focused change, watch the preview, verify it landed, then refine. Small steps beat giant prompts.
~45 min (est)9 prompts 7 beginner · 2 intermediate
03
Prompting Lovable Well: Plan in Chat Mode, Then Build
Plan in Plan mode, execute in Build mode. Attach visual references, store durable context in Knowledge, and write constraint-rich prompts that get it right the first time at the lowest credit cost.
~45 min (est)10 prompts 7 beginner · 3 intermediate
04
Visual Edits and Design Control
Polish your app by pointing, not paragraph-writing. Use the preview toolbar to edit text inline, select the exact element you mean, annotate layouts, and leave review comments, then lock in one consistent theme and a layout that holds up on a phone.
~45 min (est)9 prompts 7 beginner · 2 intermediate
Capstone · White BeltKnot open
The One-Page Startup
Prove you can drive Lovable with every control it gives you. You will take a made-up product from nothing to a polished, published one-page site, using Plan mode to think, Build mode to build, and the preview toolbar to finish. The pass bar is not that a page exists, it is that a stranger opening the live URL takes the product seriously.
  • Start a fresh project and write one well-structured Build mode prompt for a single-page site for a made-up product: who it is for, the goal of the page, the sections you want, and one constraint on style.
  • Before building the most important section, plan it in Plan mode first: ask for two layout options with tradeoffs, pick one, and only then build it. Plan mode never touches your project.
  • Refine the build with at least three follow-up prompts, each fixing one specific thing you can name (a section, a color, a piece of copy), not 'make it better'.
  • Make at least three click-based tweaks with the preview toolbar: select an element to adjust it, edit one piece of text inline, and leave one annotation or comment for the agent to act on.
  • Establish one consistent theme: a single accent color, consistent headings, and matching buttons across every section.
  • Check the page at phone width in the preview and fix everything that breaks, so the page works one-handed on a phone.
  • Add one working interaction: a signup or contact form that validates input and shows a clear success state.
  • Publish to a live URL and open it in a private, logged-out browser window; click everything once and confirm the page holds up.
DeliverableA published one-page product site at a live lovable.app URL, mobile-clean, with a validated working form, a consistent theme, and a build trail showing Plan mode thinking, targeted Build mode prompts, and preview-toolbar finishing touches.
Brown Belt
Advanced
Not started
05
Pages, Navigation, and App Structure
Grow from a single page into a real multi-page product: navigation that works on any device, a shared layout you edit once, reusable components, and dead ends designed out before anyone hits them.
~45 min (est)9 prompts 6 intermediate · 3 advanced
06
State, Data, and Logic in Plain English
Make your app do things: forms with validation, live in-app state, conditional UI, business rules, and data that travels between pages, all described in natural language.
~45 min (est)11 prompts 6 intermediate · 5 advanced
07
Going Full-Stack: Connect Supabase
Add a real database so data survives refresh. Connect your own Supabase project, approve a schema described in plain English, and wire create, read, update, and delete without writing SQL.
~45 min (est)16 prompts 6 intermediate · 10 advanced
08
Authentication and User Accounts
Add sign-up and login so each user has their own data. Wire Supabase authentication, protect private pages, and scope every record to the person who owns it.
~45 min (est)9 prompts 6 intermediate · 3 advanced
09
Payments and API Integrations
Take money with Lovable's built-in Payments, Stripe or Paddle, and extend your app with AI features and external APIs called safely from the backend with secrets.
~45 min (est)32 prompts 6 intermediate · 26 advanced
10
Debugging With Agent Mode, Versioning, and Dev Mode
When something breaks, fix it fast: let Build mode (previously called Agent mode) self-debug, roll back with version history, and drop into Dev Mode for precise control.
~45 min (est)9 prompts 6 intermediate · 3 advanced
Capstone · Brown BeltKnot open
The Two-Account Test
Build the thing that separates a page from a product: a real multi-user app where each person's data is their own. You will plan it, build it, wire a database and accounts, and then prove the walls hold by testing with two separate users. The pass bar is that account B cannot see account A's data, and you watched that happen with your own eyes.
  • Plan the app in Plan mode before building: pages, the data model, and the three core user actions. Do not build until the plan survives your own questioning.
  • Build a multi-page app with shared navigation and at least one reusable component used on two different pages.
  • Wire up a backend for your core data: Lovable Cloud's built-in database (the default), or an external Supabase connection as you practiced in module 7. Confirm records survive a page refresh.
  • Implement full create, read, update, and delete against the database, and verify each of the four by doing it and checking the data changed.
  • Add email-and-password authentication with working sign-up, login, and logout.
  • Protect every private page and scope all data to the logged-in user, then run the two-account test: create two accounts and confirm neither can see or reach the other's data.
  • Add empty, loading, and error states to every data-driven screen so the app feels finished, not fragile.
  • Use Build mode to diagnose and fix at least one real bug you found, and roll back at least one change using version history, so you have practiced both recovery directions.
DeliverableA working multi-user app with persistent data, full create-read-update-delete, real authentication, and per-user privacy proven by a documented two-account test, plus at least one fixed bug and one practiced rollback in your build history.
Black Belt
Mastery
Not started
11
Security and Supabase Row-Level Security
Before real users arrive, lock the doors: enforce Row-Level Security on your data, run Lovable's free security scans, move trust to the server, and keep secrets out of the browser.
~45 min (est)9 prompts 2 intermediate · 7 advanced
12
Deploy, Custom Domains, and Publishing
Ship it. Publish your app to a live URL, connect a custom domain, and run launches like releases: gated, verified, and reversible.
~40 min (est)8 prompts 3 intermediate · 5 advanced
13
Dev Mode, GitHub Sync, and Hybrid Workflows
Connect the no-code and pro-code worlds: read and edit source in Dev Mode, sync to GitHub, round-trip changes from an IDE or coding agent, and prove you actually own the codebase.
~45 min (est)9 prompts 2 intermediate · 7 advanced
14
Skills and Power Workflows
Scale your quality with reusable Skills and Knowledge, then put it all together on real builds: composing a SaaS skeleton, embedding AI without API keys, and bringing outside designs in.
~40 min (est)10 prompts 2 intermediate · 8 advanced
15
Teams, Scaling, and Beyond Apps
Operate Lovable like a business: run a team workspace, control who sees what, manage credit spend with actual numbers, and stretch the same skills beyond apps into dashboards, analysis, and marketing.
~45 min (est)9 prompts 2 intermediate · 7 advanced
Capstone · Black BeltKnot open
The Production Gauntlet
Ship a secure, monetized product end to end and prove you can operate it. You will compose everything the black belt covers, security, payments, AI, GitHub, Skills, and teams, into one real SaaS that survives inspection from outside. The pass bar is a stranger's experience: a live URL, a working test-mode paywall, and nothing leaking that should not.
  • Choose a simple SaaS and plan it fully in Plan mode: screens, data model, the free-versus-paid line, and one AI feature that earns its place.
  • Build accounts and your core data on Lovable Cloud with per-user data isolation. Note the constraint that shapes this choice: built-in Payments runs on Lovable Cloud and does not work with an external Supabase connection.
  • Enable the built-in Payments feature (Stripe or Paddle, paid plan required) and gate one Pro-only feature behind a subscription, then complete a full test-mode checkout in preview.
  • Embed one genuinely useful AI feature through Lovable AI, with graceful handling for empty and oversized input, and check its per-use credit cost.
  • Lock the data layer: per-user policies on every table, then run both security scans (Basic and Deep) and fix every high-severity finding.
  • Create at least one workspace Skill encoding your build standards and use it during this build, plus a browser-QA pass that produces screenshot evidence of the core flows working.
  • Connect the project to GitHub via the Lovable GitHub App, make one change locally or in an IDE, and confirm it syncs back into Lovable.
  • Publish to a live URL, connect (or fully document) a custom domain, invite one collaborator to the workspace, and verify the whole journey logged out: sign up fresh, hit the paywall, upgrade in test mode, use the paid and AI features.
DeliverableA live, monetization-ready SaaS: a public URL with a custom domain connected or documented, a test-mode paywall, one AI feature, a clean Deep security scan, a GitHub repository with a round-tripped commit, a reusable standards Skill, and a collaborator with verified access.
Beginner Intermediate Advanced Bar length is the module's prompt count against the longest module here; its segments are that module's own mix. Minutes are the curriculum's per-module estimates, summed over what you have woven.
One cell is one module, at its belt cloth Woven cell: module complete Knot open until the belt's last module is woven. Kept on this device only.
// SOURCES

Curriculum Record

Every published source this curriculum cites: 52 distinct references, counted from the curriculum brief and from the prompts themselves. Prompts that quote one carry a source line; the rest are marked unsourced author prompts.

  1. 01lovable.dev
  2. 02docs.lovable.dev
  3. 03lovable.devtop-ai-platforms-app-development-2026
  4. 04lovable.devbest-vibe-coding-tools-2026-build-apps-chatting
  5. 05lovable.devbuild-saas-product-without-coding
  6. 06lovable.devbest-saas-boilerplate-templates
  7. 07lovable.devversioning-dev-mode
  8. 08edtechinnovationhub.comlovable-adds-reusable-skills-as-ai-app-builders-move-beyond-repeated-prompting
  9. 09docs.lovable.devprojects/chat
  10. 10docs.lovable.devintroduction/faq
  11. 11docs.lovable.devagent-mode
  12. 12muz.lithe-complete-vibe-coding-guide-for-designers-2026
  13. 13lovable.devbest-ai-app-builders
  14. 14youtube.comwatch?v=aJ3yK4gFg_c&vl=en-US
  15. 15youtube.comwatch?v=Q_FZ800Hm4g
  16. 16docs.lovable.devprompting-one
  17. 17docs.lovable.devplan-mode
  18. 18docs.lovable.devfrom-idea-to-app
  19. 19docs.lovable.devfeatures/knowledge
  20. 20docs.lovable.devcredits-and-usage
  21. 21harshalpatil.substack.comvibe-coding-projects-init-2026
  22. 22docs.lovable.devpreview-toolbar
  23. 23lovable.devlovable-the-best-ai-app-builder-in-the-world
  24. 24youtube.comwatch?v=9z54zkmK-to
  25. 25clinkbill.comintegrate-stripe-lovable
  26. 26linkedin.comprajwal-tomar-9472081a5_i-one-shotted-stripe-payments-inside-lovable-activity-7423371584909963265-3AZr
  27. 27docs.lovable.devintegrations/stripe
  28. 28lovable.devvideos
  29. 29vp0.comconnect-lovable-ai-app-to-stripe-checkout
  30. 30docs.lovable.devemail-auth
  31. 31docs.lovable.devgoogle-auth
  32. 32lovable.devhow-to-connect-stripe-lovable
  33. 33lovable.devvideos/stripe
  34. 34lovable.devvideos/stripe
  35. 35dev.skill.rebuild-the-mvp-lovable-stripe-supabase
  36. 36nocode.mbalovable-tutorial-stripe
  37. 37lovable.devbuilding-a-saas-with-lovable-supabase-and-stripe
  38. 38rapidevelopers.compayment-gateway-integration
  39. 39docs.lovable.devintegrations/supabase
  40. 40docs.lovable.devprompting-debugging
  41. 41docs.lovable.devfeatures/database
  42. 42docs.lovable.devfeatures/security
  43. 43docs.lovable.devfeatures/secrets
  44. 44docs.lovable.devproject-visibility
  45. 45docs.lovable.devprojects/settings
  46. 46docs.lovable.devcustom-domain
  47. 47docs.lovable.devcode-mode
  48. 48docs.lovable.devgit-sync-overview
  49. 49docs.lovable.devprojects/remix
  50. 50docs.lovable.devfeatures/ai
  51. 51docs.lovable.devchangelog
  52. 52docs.lovable.devfeatures/people
All Modules

Get the morning Signal

175 editions so far, one a day. Unsubscribe anytime.