Lovable

From PRIMO.ai
Jump to navigation Jump to search

YouTube ... Quora ...Google search ...Google News ...Bing News


Lovable is a browser-based prompt-to-app builder. You describe the software you want in plain language, and its AI agent writes, runs, and tests a full-stack web application: the pages people see, the server code behind them, a database, user sign-in, and connections to outside services. Think of it as hiring a general contractor rather than renting a toolbox. You describe the house, approve the blueprint, and walk through each room as it is finished. If you want to pick up a hammer yourself, the code is yours to edit, download, or sync to GitHub.

Type Category Primary use Autonomy Environment
Prompt-to-app builder Knowledge Work and Productivity Agents Prompt-to-app development Delegated Browser-based builder

In the Visual and Low-Code Agent Builder Comparison, Lovable sits at the Delegated level. You hand the agent a goal, it does the work (sometimes for hours), and you review the result rather than steering every step.

Background

  • Founded in Stockholm in 2023 by Anton Osika and Fabian Hedin. It began as GPT Engineer, an open-source command-line code generator that became one of GitHub's fastest-growing projects, and was renamed Lovable in December 2024.
  • It reported $100 million in annual recurring revenue eight months after launch, and $500 million in annualized run-rate revenue by June 2026.
  • In August 2026 it raised a $400 million Series C at a $13.3 billion valuation, led by Menlo Ventures and the Scaleup Europe Fund. That roughly doubled the $6.6 billion valuation of its December 2025 round. At the time it hosted about 60 million projects drawing 900 million visitors a month.
  • In October 2026 it opened a London office, its second engineering and product hub after Stockholm, with about 70 staff.

What New Users Need to Know

Where You Work

  • Chats: Personal conversations that live outside any project. Use them to research a question with web sources, analyze an uploaded spreadsheet, draft a brief, or make a table or chart. Chats can read from connected tools such as Notion, Linear, Slack, Gmail, GitHub, and Granola, but they ask before creating, sending, or changing anything. When you ask for something to be built, the chat hands the job to a project.
  • Projects: Each project is one app, with its own chat, live preview, code, and version history. The editor puts the conversation on one side and the running app on the other.
  • Preview toolbar (formerly Visual Edits): Click an element in the live preview to select it, edit its text in place, draw an annotation, or leave a comment. It is the fastest way to say "make this bigger" without having to describe where "this" is.
  • Code mode: Browse the generated source code and edit it by hand. Editing requires a paid plan.
  • Workspace: The shared space for members, billing, a common pool of credits, and connectors.
  • Other ways in: A desktop app; iOS and Android apps (launched April 2026) for queuing prompts on the go; Lovable in Slack; a Telegram bot; a ChatGPT app; and a Lovable MCP server that lets other AI assistants work with your Lovable projects.

Three Modes: Chat, Plan, Build

A mode picker in every project chat decides how much the agent is allowed to change. You can switch at any time, and the conversation carries over.

  • Chat mode: Talk through ideas, ask how something works, or compare options. No code changes.
  • Plan mode: The agent investigates your project, sends out research subagents if needed, and writes a plan you can edit and approve. Plan mode never modifies the project, and it costs one credit plus any subagent research. It is like approving the architect's blueprint before the crew pours concrete. Earlier versions of a plan are kept so you can compare and restore them.
  • Build mode (formerly Agent mode): The agent does the work. It explores the codebase, edits files across the frontend, backend, and configuration, reads build errors, console output, and network requests to fix its own mistakes, searches the web, and can generate images. A single message can run for up to 10 hours. Goal runs go further: you set a target and Lovable keeps working until it is met.

Essential Controls

  • Instructions (formerly Knowledge): Standing guidance Lovable remembers across conversations. Workspace instructions apply to every project; project instructions hold things like user personas, coding conventions, and design notes. This is Lovable's equivalent of a system prompt.
  • Skills: Reusable, named playbooks written in markdown at the workspace level. Run one with a / command, or let Lovable apply it when a matching task comes up.
  • Credits: Building is metered in credits, based on how much work a request takes, and many requests cost less than one credit. Lovable's pricing page, for example, prices "make the button gray" at 0.5 credits and "add authentication with sign up and login" at 1.2. Credit check-ins (20 credits by default) pause a long job so you can decide whether to continue, and if you stop a request you pay only for the work already done.
  • Version history and remix: Roll a project back to an earlier state, or remix it into an independent copy to try a different direction without touching the original.
  • Security scans: A free quick scan of the database, dependencies, and MCP servers runs on every publish. A deep scan reviews the application code for harder-to-spot problems; it is free when you start it yourself, and scheduled deep scans cost 1 credit per project per run.

Plans at a Glance (October 2026)

Plan Price Highlights
Free $0 5 daily build credits (capped at 30 a month), unlimited members, Git sync, custom connectors
Pro From $25/month for 100 credits Edit and download code, custom domains, badge removal, design systems, credit rollovers and top-ups
Business From $50/month for 100 credits Everything in Pro plus SSO, role-based access, design templates, a security center, the Lovable API, and exclusion from model training by default
Enterprise Custom contract Everything in Business plus SCIM, audit logs, data exports, EU inference, and dedicated support

Free, Pro, and Business also get a monthly grant of 20 Cloud credits and 4 AI credits, which cover hosting, the backend, and AI features in published apps. Plans are priced by credits, not by seats.

Technical Architecture and Capabilities

What Lovable Generates

  • Web apps, not native apps: Projects created since May 13, 2026 (June 22 for Enterprise workspaces) use a TanStack Start template that renders each page on the server, which helps search engines and link previews. Older projects use React with Vite and render in the browser; Lovable can upgrade them. You cannot choose a different framework. Lovable can build installable progressive web apps (PWAs), but not native iOS or Android apps.
  • A PostgreSQL database in every project, through either the built-in backend or your own Supabase project.
  • Code you own: Your apps, code, and content belong to you. Paid plans can download the whole codebase as a .zip file, and every plan can sync to a new GitHub, GitLab, or Bitbucket repository so you can keep working in other tools. Projects can also be imported from Replit, Bolt, v0, or a ZIP upload.

Lovable Cloud (the Built-in Backend)

Lovable Cloud hosts the app and runs its backend with no outside setup. It is built on Supabase's open-source foundation and includes:

  • A database with access rules, backups, and load monitoring. Since October 2026, schema changes are saved as Drizzle migration files, and changes that could break a published app are avoided by default.
  • Sign-in by email, phone, Google, Apple, Microsoft, SAML single sign-on, OpenID Connect, or "Sign in with Lovable."
  • File storage, realtime updates, edge functions for server-side code, scheduled jobs, secrets, and logs.

Teams that already use Supabase can connect their own project instead. Moving a Supabase-connected project onto Lovable Cloud is not supported, and moving the other way is a manual export and restore.

Lovable AI: Models Inside Your App

Ask for a chatbot, a summarizer, or an image generator, and Lovable connects it to a built-in AI gateway. There is no provider account or API key to manage. Lovable creates a LOVABLE_API_KEY for each project and calls the model from a server-side function, so credentials and prompts never reach the browser. (This is the same "keep the key on the server" pattern that Google AI Studio adopted for its Build mode.) As of October 2026 the catalog includes:

  • Text and reasoning: OpenAI GPT models (GPT-6 Astra is the default for chat), Google Gemini Flash models and Gemini 4 Argon for the hardest reasoning, and Anthropic Claude models in newer apps.
  • Media: Image generation and editing, video (Gemini Omni and Veo 3.1), and music (Lyria 3).
  • Search and decisions: Embeddings for semantic search and retrieval-augmented generation (RAG), plus a dedicated model for classification, routing, and scoring.
  • Voice: Text-to-speech, transcription with automatic language detection across more than 85 languages, and live two-way voice assistants.

AI use in published apps is metered in credits by model and volume. Rate limits apply per workspace. An app that exceeds them gets an HTTP 429 error, and one that runs out of credits gets HTTP 402, so build friendly error messages for both.

Under the Hood: Technologies Implemented

  • Model independence: Lovable doesn't make you pick a model. It tests candidate models inside its own agent loop, sends each kind of work to whichever model does it best, and can route a call to another provider when one is overloaded. By August 2026, Lovable's own post-trained models were handling a meaningful share of app-building work in production. It's like a general contractor who hires the best electrician and the best plumber for each job instead of one handyman for everything.
  • Subagents: Plan mode can dispatch research helpers that dig through the codebase or the web and report back.
  • Memory: Lovable keeps track of what it learns about your project as you build, so you repeat yourself less.
  • Browser testing: The agent drives your app in a real browser. It clicks buttons, fills in forms, and takes screenshots, and since September 2026 it can sign in to check pages behind a login.
  • Connectors: There are three kinds, and the difference matters for privacy:
    • App + chat connectors are one shared account that Lovable uses while building and your published app uses at runtime, like an office's shared company login.
    • App user connectors let each person using your app connect their own account (Gmail, Slack, Salesforce, GitHub, Linear, and others). Requests run with that person's permissions and see only their data, like each employee carrying their own key card. Tokens are stored encrypted in Lovable's connector gateway, and your app code never handles them.
    • Chat connectors are MCP servers that give Lovable context while you build, such as your Notion specs or Jira tickets. They are never part of the published app.
    • The catalog spans data warehouses (Snowflake, BigQuery, Databricks, Redshift), CRMs (Salesforce, HubSpot), messaging (Slack, Twilio, WhatsApp Business), web research (Perplexity, Firecrawl, Parallel), payments (Stripe), commerce (Shopify), and workplace suites (Google Workspace, Microsoft 365, Notion). Since August 2026 you can also define a custom connector for any REST API.
  • Publishing: Publishing takes a snapshot and puts it on a public URL, so later edits go live only when you republish. A lovable.app address is free on every plan; custom domains need a paid plan. An app can also be published as an MCP server so that AI assistants can use it as a tool.
  • Governance: SOC 2 Type II, ISO 27001:2022, and AIUC-1 certifications; SSO, SCIM, audit logs with export to SIEM tools, sensitive-data scanning, EU-only inference, and Wiz and Aikido security integrations. Lovable is not HIPAA-compliant. Starting September 9, 2026, data from Free and Pro plans may be used to train AI models unless you opt out; Business and Enterprise data is excluded by default.
  • Deploy on AWS (private preview): Selected Enterprise customers can run the app data plane, published apps, database, storage, and connector gateway in their own AWS account, while the editor and agent stay with Lovable.

Examples and Use Cases

  • Internal tools built by non-engineers: At the meal-replacement brand Huel, about 300 employees have built more than 200 internal tools on Lovable, which Lovable says has cut more than £85,000 a year from Huel's software spending.
  • Founder MVPs: Describe the product, start in Plan mode, approve the plan, and publish a working app with sign-up, a database, and Stripe payments without leaving the browser. Sync to GitHub when a developer joins.
  • Data apps: Connect Snowflake, BigQuery, or Databricks and ask for a dashboard. With app user connectors, each viewer sees only the rows their own credentials allow.
  • Long-horizon builds: To show off 10-hour runs, Lovable asked its agent to build a guitar-chord recognizer with no training data supplied. The agent generated about 23,000 synthetic samples, found the public GuitarSet dataset, trained several model versions, and shipped a browser app built around a 2,185-parameter network.
  • Building on the go: Queue a prompt from the Lovable mobile app on your Pixel 10 XL Pro, put the phone away, and get a notification when the build is ready to review. Because Lovable makes web apps, install the result from Chrome as a PWA rather than side-loading an APK.
  • Research before building: Open a Chat, attach last quarter's support-ticket export, and ask which three problems an internal tool would fix first. When you like the answer, ask the chat to hand the build to a new project.

Lovable vs. Google AI Studio Build Mode

Lovable Google AI Studio Build mode
Built for Founders, product managers, designers, and business teams shipping web apps Developers prototyping on Gemini models
Models Model-independent: mixes providers and its own post-trained models for the build agent; OpenAI, Google, and Anthropic models for app features The Gemini family
Output Web apps (TanStack Start; older projects React + Vite) and PWAs React web apps with a Node.js server, or native Android apps in Kotlin
Backend Lovable Cloud (Supabase-based PostgreSQL) or your own Supabase Firebase Firestore and Google sign-in
Point-and-edit Preview toolbar Annotation mode
Hosting lovable.app addresses or custom domains; AWS in private preview Cloud Run
Paying for it Credits for building, plus Cloud and AI credits for running The owner's Gemini API quota and model costs

Load video
YouTube
Load video
YouTube
Load video
YouTube

Design an Agent App: Follow-Through in Lovable

Follow-Through is a small internal app that turns meeting notes into action items, routes each item to its owner, and sends nothing until a person approves it. It matches Lovable's place in the comparison table twice over: you delegate the build to Lovable's agent, and the finished app is itself a knowledge-work agent that takes over the tedious parts of follow-up while keeping people in charge of anything that goes out under their name.

Delegation and Knowledge-Work Agents

What "Delegated" looks like in practice

Agent tools sit along a spectrum. At one end, an assistant suggests and you act. At the other, an agent acts on its own and you audit afterward. Delegation is the middle ground: you hand over a well-defined job, the agent does it end to end, and you review the result before it counts. Lovable's controls map onto that idea:

  • Plan mode is the review gate before work starts.
  • Credit check-ins are budget checkpoints during long jobs.
  • Goal runs move toward full autonomy by letting the agent keep going until a target is met.
  • Version history is the undo button when you disagree with the result.

Two layers of delegation

When you build an agent app in Lovable, there are two agents to supervise. The build agent writes and tests the code, and you supervise it through plans, previews, and tests. The runtime agent is the AI feature inside your app: the model that reads meeting notes and proposes tasks. Your users supervise that one, so the app has to make review fast and obvious.

Why approval gates matter

A model reading messy notes will sometimes invent an owner, misread a date, or turn a passing idea into a commitment. The cheapest fix is usually not a better model but a better design. Every proposed action carries the evidence it came from, low-confidence items are flagged, and nothing goes out under someone's name until that person clicks Approve.

What Lovable provides

As of October 2026, a Lovable project can:

  • Generate the full app from a prompt, with a PostgreSQL database, Google sign-in, access rules that limit who sees which rows, and an audit table in Lovable Cloud.
  • Call a Claude, GPT, or Gemini model from a server-side function through Lovable AI, with no API key to manage, and request structured JSON output.
  • Connect each user's own Slack and Linear accounts with app user connectors, so posts and issues are created with that person's permissions.
  • Run a scheduled job for daily reminders.
  • Test the sign-in flow and the approval board in a real browser before you publish.

App user connectors need an OAuth app registered with each provider (here, Slack and Linear) before users can connect. Every scheduled job run and AI call uses Cloud and AI credits, so set workspace usage limits before rolling the app out.

Workflow stages

Stage Knowledge-work idea What people do What the agent does Guardrail
1. Capture Getting information into the system Paste notes or upload a .txt or .md transcript Stores the raw notes on a meeting record Only attendees and the organizer can see the meeting
2. Extract Turning prose into structured tasks Click Extract Returns JSON for each item: task, owner, due date, priority, confidence, and an exact supporting quote Items whose quote is not found in the notes are discarded; low-confidence or ownerless items go to "Needs review"
3. Review Human in the loop Approve, edit, or reject each card, with its supporting quote highlighted in the notes Waits Every edit and decision is written to the audit log
4. Act Delegated action The owner picks Slack, Linear, or both, and sees the exact text first Drafts the message or issue Sends only after approval, through the owner's own connected account
5. Follow up Closing the loop Approve or dismiss a reminder A weekday 8 AM job finds approved items due within two days and drafts a nudge Reminders are drafts and are never sent automatically

Guardrails (the most important part of the design)

  • The agent proposes; people approve. No Slack post, Linear issue, or reminder goes out without a click from the item's owner or the meeting organizer.
  • No evidence, no task. Each action item must include a quote copied from the notes, and the server checks that the quote really appears there before saving the item.
  • Structured answers. Every model call asks for JSON with fixed fields, validated on the server, so routing is done by code rather than by parsing prose.
  • Each user's own permissions. App user connectors mean the app can do only what the signed-in person could already do in Slack or Linear.
  • Keys and prompts stay on the server. Lovable AI calls run in a backend function, and connector tokens stay in Lovable's gateway.
  • Check the training-data setting. Meeting notes are sensitive. On Free and Pro plans, opt out of model training in account settings, or build in a Business or Enterprise workspace, where data is excluded by default.

Build prompt for Lovable

Paste this into a project chat in Plan mode, review the plan, then switch to Build mode: 

Build an internal web app called "Follow-Through" that turns meeting notes into tracked,
approved action items. Use Lovable Cloud for the backend and Google sign-in for my team.

Core rule
- The agent proposes; a person approves. Nothing is posted to Slack, created in Linear,
  or sent as a reminder until the item's owner or the meeting organizer clicks Approve.

Data model
- meetings: title, date, organizer, attendees, raw_notes, created_at
- action_items: meeting_id, task, owner, due_date, priority, confidence (0 to 1),
  source_quote, status (proposed, needs_review, approved, rejected, sent, done)
- audit_log: user, action, item_id, timestamp, and the model's raw JSON for each extraction
- Access rules: people see only meetings they attended or organized.

Step 1: Capture
- Let users paste notes or upload a .txt or .md transcript, and pick attendees from
  the team list.

Step 2: Extract
- Send the notes to a server-side AI function using Lovable AI. Ask for JSON only: an array
  of items with task, owner (must be an attendee or null), due_date (ISO date or null),
  priority (low, medium, high), confidence, and source_quote (a sentence copied exactly
  from the notes).
- Validate the JSON on the server. Discard any item whose source_quote does not appear
  in the notes.
- Items with confidence below 0.6, no owner, or no due date get status needs_review.

Step 3: Review
- Show a board with columns Proposed, Needs review, Approved, Sent, Done.
- Clicking a card highlights its source quote in the original notes.
- Approve, edit, or reject in one click. Log every edit and decision to audit_log.

Step 4: Act
- On approval, the owner chooses: create a Linear issue, post to a Slack channel, or both.
- Use app user connectors for Slack and Linear so each action runs with the owner's own account.
- Always show the exact message or issue text and require a final Send click.

Step 5: Follow up
- Add a scheduled job that runs on weekdays at 8 AM, finds approved items due within
  2 days that are not done, and creates a draft reminder for the owner to approve.
  Never send reminders automatically.

Design
- Calm, high-contrast productivity look. Proposed items are amber, approved are green,
  rejected are gray. Works well on phones. Add a short "How it works" panel explaining
  extraction, review, and approval. Show friendly messages if the AI is rate limited
  (HTTP 429) or out of credits (HTTP 402).

Building and testing it

  1. Add Instructions first: who the users are, that every outbound action needs approval, and your house style for messages.
  2. Paste the prompt in Plan mode and read the plan. Check the data model and the approval rule before you approve it; a plan costs about one credit and can save many.
  3. Switch to Build mode and let the agent work. Keep credit check-ins on for the first run.
  4. When Lovable asks, register Slack and Linear OAuth apps and add them as app user connectors. Test with two accounts to confirm that each request uses the right person's connection.
  5. Ask Lovable to run browser testing on the whole flow: sign in, paste sample notes, approve one item, reject another, and confirm that the audit log records both.
  6. Feed it a tricky transcript (two people with the same first name, a deadline of "next Friday," an idea nobody agreed to) and confirm those items land in "Needs review."
  7. Run a deep security scan, fix what it finds, then publish. Set workspace usage limits and alerts before inviting the team.

Extensions

  • Voice stand-up: Add a live voice assistant so people can say "mark the pricing deck as done" instead of clicking.
  • Assistant access: Publish the app as an MCP server so Claude, ChatGPT, or another MCP client can list open items and create drafts for approval.
  • Weekly digest: Add the published app as a tool in a Lovable Chat and ask for a Friday summary of what slipped.
  • Meeting imports: If your workspace has a Granola or Fireflies connector available for published apps, connect it so notes arrive without copy and paste.
  • Completion analytics: Send approved and completed items to Snowflake or BigQuery and build a dashboard of follow-through rates by team.
  • Head-to-head test: Rebuild Peekaboo Protocol in Lovable from the same spec to compare the two builders on identical requirements.
Retrieved from "https://primo.ai/w/index.php?title=Lovable&oldid=53446"