skip to content

Lovable

Lovable builds a full-stack web app from a prompt in Chat, Plan and Build modes, on TanStack Start with a Supabase-based backend, Git sync and security scans. Asked about who owns the generated code.

part ofAI coding toolsread it →
on this pageshow

explore

questions

6

In a Lovable project chat, which of Chat, Plan and Build modes can change the app's code, and what do the other two do instead?

level: juniorimportance: must knowfreq 10%

answer

  1. three modes, one shared conversation
  2. mode picker beside the chat input
  3. Option+P or Alt+P cycles them
  4. an approved plan switches modes
  5. the building mode's former name

basics

~20 s

Only Build mode, previously called Agent mode, changes the app. Plan mode investigates and writes an editable plan you approve, then hands over to Build; Chat mode discusses the project and never changes its code or data.

solid answer

~40 s

A Lovable project chat has three modes in the picker next to the input, and **Option+P** (Mac) or **Alt+P** (Windows/Linux) cycles them. **Build mode** (previously Agent mode) is the one that edits files, runs migrations and verifies the result, and it is active unless you switch away. **Plan mode** investigates the project and, when there is a clear change to propose, writes a plan in the Plan view that you can edit, comment on and **Approve** — approval switches the chat to Build mode, which implements it; Plan mode itself never modifies code. **Chat mode** answers questions about the project and can outline steps in prose, but creates no plan and changes no code or data; asking it to build shows a **Start building** card. The conversation carries across all three.

go deeper

for a junior

Recall that Build mode, formerly Agent mode, is the only one that edits the app, that Plan mode ends in an Approve step, and that Option+P or Alt+P cycles the three modes.

for a middle

Explain the hand-offs: Chat mode's Start building card, Plan mode's approval switching to Build, and where plans persist as files. Mention that connector actions can still run from Chat mode.

for a senior

Show how you would use Plan mode for risky schema or auth changes so a reviewer sees the approach first, and why the plan files in the repository help a team audit decisions later.

for a principal

Weigh where a team's review gate should sit for a builder that edits directly: an approved plan before the build, versus reviewing the synced diff afterwards, and what each catches.

## Three modes in one project chat Every Lovable project has a **project chat**, the conversation in which you ask Lovable to work on the app. Next to its input sits a **mode picker** showing the current mode. There are three modes, and the docs summarise them in one line: Chat mode helps you decide what you want, Plan mode defines how to build it, Build mode changes the app. You can switch at any time — from the picker or by cycling with **Option+P** on a Mac or **Alt+P** on Windows and Linux — and the conversation carries across all three, so context gathered in one mode is available in the next. | Mode | Described as | Changes code or data? | What it produces | |---|---|---|---| | **Chat** | "Ask anything, explore ideas" (picker) | Never | Answers and prose outlines in the conversation | | **Plan** | "Detailed spec for complex builds" (picker) | Never | A structured plan in the **Plan view** you edit and approve | | **Build** | "implement changes and verify the outcome" (docs) | Yes | File edits, migrations, verification, shown as diffs | ## Build mode: the only mode that edits the project **Build mode** was previously called **Agent mode**; the old name survives in older tutorials and the changelog, but the picker now says Build. It is the active mode unless you switch to Chat or Plan. In Build mode Lovable: - explores the codebase, applies changes across files and resolves errors it meets; - shows its progress as tasks, with a **Details view** whose **Timeline** tab lists each step and tool call and whose **Changes** tab shows the file changes; - can run verification tools such as browser testing when asked; - accepts follow-up messages mid-run and folds them in at its next natural stopping point. All of its changes are applied directly to the project. The **stop button** halts a request and keeps the work done so far; the **undo button** reverts to the previous state if you want the changes gone too. ## Plan mode: a plan you approve, never an edit **Plan mode** investigates the project — files, logs and other context, sometimes with subagent research — and often asks clarifying questions first. A plan is created only when there is a clear implementation to propose; a Plan mode conversation can end with no plan at all. When it does produce one, the flow is: 1. The plan opens in the **Plan view**: an overview, key decisions, components and data models, and step-by-step sequencing. 2. You edit it directly, or highlight a section and use **Comment** to ask Lovable to revise just that part; revisions are kept as versions you can step through. 3. You select **Approve** (or **Skip** to move on without it). Approval switches the chat to **Build mode**, and implementation starts immediately from the approved plan. The plan being worked on lives in `.lovable/plan.md`; on approval Lovable moves it into the `.lovable/plan/` folder as a dated file, so past plans stay in the project alongside the chat history. ## Chat mode: discussion, with one caveat **Chat mode** reads the project's code and files, the app's data when Lovable Cloud is connected, the conversation so far and any projects you reference. It answers how something works, compares options and can outline an approach in prose. While it is active, Lovable does **not**: - create or edit project files; - change database data or run migrations; - enable Cloud, authentication or email sending; - publish the app or create a plan in the Plan view. If you ask it to build, fix or publish something, it shows a **Start building** card marked **(Uses credits)**: **Build** switches to Build mode and makes the change, **Skip** keeps Chat mode and nothing changes. The caveat: Chat mode is read-only for **your project**, not for **connected tools**. An action through a connector — posting to Slack, creating an issue in a tracker — can run in Chat mode; Lovable asks for approval first unless you saved an **Always allow** answer for that tool. ## Common mix-ups - Treating Plan mode as "a cheaper Build mode": it never writes code, and the build after approval is billed as Build work separately. - Expecting Chat mode to leave a plan behind: only Plan mode writes to the Plan view and `.lovable/plan.md`. - Hunting for an "Agent mode" switch: that is Build mode's former name, not a fourth mode. - Sending `/goal` in Plan mode: a goal always runs in Build mode, and the picker switches to Build.

  • Where does a Lovable plan live after you approve it, and why does that matter to a team?
    While you work on it the plan is in `.lovable/plan.md`; on approval Lovable moves it into the `.lovable/plan/` folder as a dated file named after the plan, and `.lovable/plan.md` starts fresh. Because these are ordinary project files, they sync to the repository like any other code, so a new collaborator can read why a feature was built the way it was.
  • Can a Lovable Chat mode conversation have side effects at all?
    Not on the project: Chat mode never edits files, changes database data, runs migrations or publishes. It can act through connected tools — sending a Slack message, creating an issue — after asking for approval, or without asking if you saved **Always allow** for that tool. And selecting **Build** on its **Start building** card switches to Build mode, which then makes the change.

  • Plan mode makes small code changes while it investigates
  • Chat mode cannot do anything outside the conversation
  • Agent mode is a fourth mode beside Chat, Plan and Build
  • Approving a plan only saves it; you start the build yourself
  • Build mode waits for you to approve every file edit
open as a page

Lovable projects created in January 2026 and August 2026 — which stack does each run on, and what does upgrading the older one change?

level: juniorimportance: should knowfreq 5%

basics

~20 s

The January project runs Lovable's older React + Vite stack; the August one runs TanStack Start, the default for new projects since May 13, 2026. Upgrading converts pages to server-side rendering; the live site changes only on the next publish.

open as a page

For a new Lovable project, what changes if you connect your own Supabase project instead of using Lovable's built-in Cloud backend?

level: middleimportance: should knowfreq 4%

basics

~20 s

Ownership and management move to you: your own Supabase account, billing and dashboard instead of Lovable credits and the Cloud view. You lose Cloud-only features such as in-editor backups and chat-configured auth, and no one-click migration exists either way.

open as a page

A founder's Lovable prototype is being handed to an in-house team that requires reviewed pull requests on main — how should Lovable's two-way Git sync be set up, and what does the repository not carry?

level: seniorimportance: should knowfreq 6%

basics

~20 s

Let Git sync create a repository the team owns, keep Lovable on its own feature branch merged through reviewed pull requests, and never rewrite the synced branch. The repository holds code and migration files, not data, secrets or deployments.

open as a page

A published Lovable app passed its Quick scan, yet any visitor can read every customer's records — which limits of Lovable's built-in scans explain that?

level: seniorimportance: should knowfreq 5%

basics

~20 s

Lovable's Quick scan checks database access rules, npm dependencies and MCP exposure, not application code. Service-role server code bypasses row-level security unseen; the on-demand Deep scan reviews it, and critical findings block publishing only if the workspace enables that.

open as a page

In Lovable, how do workspace knowledge and project knowledge differ in scope and in who may edit them, and which wins when they conflict?

level: middleimportance: nice to knowfreq 3%

basics

~20 s

Workspace knowledge holds rules for every project in a workspace and only owners and admins edit it; project knowledge holds one project's context and anyone who can edit the project can change it. On conflict Lovable generally prioritises project knowledge.

open as a page