- Lovable terminology covers terms specific to the Lovable platform, its features, and how it works.
- General development concepts covers web, design, and backend terms that aren’t Lovable-specific but show up often in the docs.
Lovable terminology
Modes and how Lovable works
- Build mode: Lovable’s execution mode for implementing changes directly in your project. The agent writes code, runs tools, applies changes across files, and verifies the result. Use Build mode when you’re ready to ship a change. (Previously called Agent mode.)
- Plan mode: Lovable’s reasoning and brainstorming mode. Use it to explore ideas, compare approaches, investigate issues, and review or edit a plan before any code changes. Plan mode never modifies your project.
- Subagents: Temporary, read-only agents that Lovable spins up to research, inspect, or review focused parts of a task in parallel. Subagents report findings back to the main agent but cannot change your project.
- Prompt: A natural-language instruction you send to Lovable to create, modify, debug, or explain something in your app.
- Prompt queue: A queue of prompts you can send while Lovable is already working. Queued prompts can be reordered, edited, paused, or removed before they run.
- Diff: A side-by-side comparison of file changes Lovable made in a turn.
- History: The chronological log of changes to your project. Lets you revert to a previous version or bookmark important checkpoints.
- Visible tasks: The step-by-step progress view that shows what Lovable is doing during a Build mode run, including which files it’s touching.
Workspace, projects, and people
- Workspace: The top-level container for your team’s projects, members, billing, and settings. Every project lives inside a workspace.
- Workspace admin settings: The central place where workspace owners and admins configure identity, access, templates, billing, domains, security, and developer settings for the workspace.
- Project: A single Lovable app, with its own code, chat history, integrations, and settings. Projects always belong to a workspace.
- External collaborator: Someone outside your workspace who has been granted access to a specific project. External collaborators don’t have a seat in the workspace itself.
- Project access (project visibility): Controls who can open and edit a project in the Lovable editor: Workspace or Restricted (Business and Enterprise).
- Restricted project: A project visible only to people explicitly added to it, even within the workspace. Available on Business and Enterprise plans.
- Share dialog: The dialog where you invite people or groups to a project, manage roles, and copy invite links.
- Groups: Named collections of workspace members used to grant access to projects, folders, and published apps in bulk. Groups can also sync from your identity provider via SCIM. Available on Business and Enterprise plans.
- SSO (Single sign-on): Workspace-level authentication through your identity provider (Okta, Microsoft Entra ID, Auth0, Google Workspace) using OIDC or SAML.
- SCIM provisioning: Automatically create, update, and remove workspace users (and sync groups) from your identity provider.
- Audit logs: A searchable trail of workspace activity showing who did what, when, and to which resource. Enterprise plans.
Building and editing
- Preview: The live, interactive view of your app inside Lovable. The preview updates as Lovable builds, and you can interact with it the same way an end user would.
- Preview toolbar: The toolbar on top of the preview that lets you select elements, edit text inline, draw annotations, and leave comments without leaving the preview. Replaces the older Visual edits panel.
- Code editor: The in-Lovable view for browsing and manually editing your project’s source code. Available on paid plans. (Sometimes called Code mode.)
- Knowledge: Persistent instructions Lovable remembers across conversations. Split into workspace knowledge (rules and standards that apply to every project in the workspace) and project knowledge (project-specific context, personas, conventions, and design notes).
- Skills: Reusable, named playbooks defined at the workspace level. Each skill packages markdown instructions that Lovable applies whenever a matching task comes up, either invoked with a
/command or triggered automatically. - Cross-project referencing: Pull code, assets, files, or chat history from another project in your workspace using
@mentions, so you can reuse implementations without rebuilding them. - File generation: Ask Lovable to analyze data or generate downloadable files (CSV, PDF, Excel, charts) directly in the chat, without modifying your project’s source code.
- Browser testing: Lovable interacts with your app in a real browser, clicking, filling forms, and capturing screenshots, to verify user flows end to end.
- Testing tools: The umbrella feature covering browser testing, frontend tests (Vitest + React Testing Library), and edge tests (Deno test runner for edge functions).
- Remix: Reuse the current state of a project as the starting point for a new one. Remixing creates a copy you can edit independently while preserving the original. You can remix one of your own projects, any project you have access to, or another user’s project that has public remixing enabled.
Design
- Design guidance: The pre-build step where Lovable either shows three lightweight design directions to compare, asks design questions about typography, color, and layout, or builds directly when the visual intent is already clear.
- Design directions: Three side-by-side HTML and Tailwind previews Lovable can generate before a build, so you can pick a visual direction before committing.
- Design systems: An Enterprise-only feature for defining a reusable React component library, styling guidelines, and setup instructions in a dedicated Lovable project. Other projects in the workspace can connect to that design system and receive updates.
- Design templates: Approved Lovable projects marked as reusable. Starting a new project from a template copies the full codebase, including structure, components, configuration, and styling. Available on Business and Enterprise plans.
Publishing, hosting, and domains
- Publish: Deploy your project to a public URL. Publishing creates a snapshot; later edits require republishing to go live.
- Website access: Controls who can visit your published app. Options include anyone (public) or workspace only (Business and above).
- Custom domain: A domain you own (e.g.
yoursite.com) connected to a published Lovable project. You can connect a domain from another registrar or buy one through Lovable. - Transfer a domain: Move a domain you already own from another registrar into Lovable, so Lovable becomes the registrar.
- Branded app URLs: A workspace-level subdomain that replaces the default
your-app.lovable.appwith{app-name}.{workspace-subdomain}.lovable.appfor every app in the workspace. Available on Business and Enterprise plans. - Analytics: Built-in traffic and engagement metrics for published projects.
- SEO and AI search (AEO): The combined tab for Search Engine Optimization and Answer Engine Optimization. Includes on-demand SEO reviews, sitemap/robots/llms.txt checks, Lighthouse performance, Semrush keyword research, and Google Search Console setup.
Lovable Cloud
- Lovable Cloud: Lovable’s built-in full-stack platform with database, authentication, storage, edge functions, and AI for your app, all with no external setup.
- Edge functions: Serverless TypeScript functions that run close to your users. Used for APIs, webhooks, scheduled jobs, and integrations with third-party services.
- Secrets: Securely stored API keys, tokens, and credentials. Lovable Cloud automatically injects secrets into edge functions.
- Google auth (Cloud apps): Add Sign in with Google to a Lovable Cloud app using Lovable-managed OAuth or your own Google Cloud credentials.
- SAML SSO (Cloud apps): Let end users of your Lovable Cloud app sign in with their company identity provider (Okta, Entra ID, Google Workspace, OneLogin, JumpCloud, or any SAML 2.0 IdP). Configured per project. Different from workspace SSO.
- Custom emails: Send authentication and app emails from your own domain with automatic SPF, DKIM, and DMARC setup to improve deliverability.
- Payments: Built-in subscriptions and one-time payments powered by Paddle or Stripe.
Security
- Security overview: The umbrella for Lovable’s built-in security: Basic and Deep scans, API key protection, RLS checks, dependency audits, and optional security connectors.
- Basic scan: A fast configuration and dependency check that runs locally inside Lovable. Free, doesn’t consume credits.
- Deep scan: A more detailed, agentic code review for harder-to-detect vulnerabilities. Free, doesn’t consume credits.
- Security view: Per-project tab showing scan results, dependency findings, and security recommendations.
- Security center: Workspace-level dashboard that aggregates security findings, scan coverage, scheduled scans, secrets, and dependency risks across every project. Business and Enterprise plans.
- Workspace insights: Portfolio view in the Security center that combines security findings, PII, ownership, lifecycle, publish status, and activity into a single review priority per project. Enterprise plan.
- Privacy & security settings: Workspace-wide controls for default project access, publishing permissions, MCP access, sensitive data scanning, and data protection.
- Data opt-out (training data and privacy): Enterprise option to exclude your workspace’s data from being used for AI training.
Integrations
- Chat connectors (MCP servers): Connect Lovable to your personal accounts in tools like Notion, Linear, Jira, Confluence, or Miro using the Model Context Protocol. Pulls real context from those tools directly into chat.
- Lovable MCP server: An MCP server that lets external AI agents and developer tools (ChatGPT, Claude Desktop, Cursor) build, iterate on, and deploy Lovable apps programmatically.
- Lovable AI: Built-in AI models you can use inside the apps you publish, for chatbots, summaries, sentiment detection, image generation, semantic search, and more. No API keys required.
- Build with URL: Create Lovable apps from a URL by passing prompts and images as parameters. Useful for embedding “Build with Lovable” buttons or automating app generation.
- Lovable desktop app: A native macOS app with multi-tab project management, local MCP support (Figma, Paper), and keyboard shortcuts.
- Lovable mobile app: The mobile companion app for building and reviewing Lovable projects on the go.
- Supabase: Open-source backend-as-a-service. Can be connected to Lovable projects as an alternative to Lovable Cloud.
- GitHub integration: Two-way sync between a Lovable project and a GitHub repository for version control, code review, and developer collaboration.
Plans, credits, and billing
- Credits: Units Lovable uses to measure and pay for credit-based usage across your workspace. Credits can be used for building your app, hosting and running it with Lovable Cloud, and powering AI features in deployed apps.
- Credit top-up: An optional purchase of additional credits available on Pro and Business plans, separate from your monthly subscription. Top-ups can be purchased manually as a one-time top-up or automatically with auto top-up.
- Daily build credits: Credits granted every day on Free, Pro, and Business plans for Build usage only. Free, Pro, and Business plans include 5 daily build credits that reset every day at 00:00 UTC and do not roll over. Free daily build credits are capped at 30 per calendar month. Pro and Business daily build credits do not have a monthly cap.
- Usage-specific grants: Included credits that apply only to one type of usage, such as daily build credits, the monthly Cloud grant, or the monthly AI grant. Usage-specific grants are used before general credits and do not roll over. Daily build credits reset every day at 00:00 UTC. On Free plans, monthly Cloud and AI grants reset on the 1st of each calendar month at 00:00 UTC. On Pro and Business plans, the monthly Cloud grant refreshes with the subscription billing cycle.
- General credits: Credits that can be used after usage-specific grants run out to build your app, host and run your app with Lovable Cloud, and power AI features in deployed apps. General credits include monthly plan credits, top-up credits, and bonus credits.
General development concepts
These terms are not Lovable-specific. They come up across web, design, and backend development and are included here as a reference when you see them in the docs.Frontend and UI
- Frontend: The part of an app users see and interact with in the browser.
- React: The JavaScript library Lovable uses to build user interfaces.
- Tailwind CSS: The utility-first CSS framework used to style Lovable projects.
- Component: A reusable piece of UI (button, card, form, navbar) that combines to build pages.
- Responsive design: Layouts that adapt to different screen sizes such as mobile, tablet, and desktop.
- Hero section: The prominent area at the top of a landing page, typically containing a headline, subheading, and call to action.
- CTA (Call to action): A button or link prompting users to take an action, such as “Sign up”, “Get started”, or “Buy now”.
- Modal / Dialog: An overlay window that interrupts the main flow to capture attention or input.
- Toast: A brief, non-intrusive notification that appears temporarily.
- Tooltip: A small popup that appears on hover or focus to provide extra information.
- Skeleton loader: A placeholder UI that mimics the final layout while real content is loading.
- Above the fold: The portion of a page visible without scrolling.
- Breadcrumb: A navigational element showing a user’s location within the site hierarchy.
- Favicon: The small icon shown in browser tabs and bookmarks.
Design language and styles
Use these terms in prompts to steer Lovable toward a specific aesthetic.- Glassmorphism: Translucent, frosted glass elements with blur and subtle borders.
- Neobrutalism: Bold, raw, high-contrast design with unpolished edges and chunky typography.
- Minimal: Clean layouts, lots of whitespace, restrained color and type.
- Premium: Refined, sophisticated, attention-to-detail aesthetic.
- Retro: Visual styles borrowed from past decades, such as neon, pixel, or vintage.
Backend, databases, and APIs
- Backend: The server-side of an app, including data, business logic, authentication, and integrations.
- API (Application Programming Interface): A contract that lets two software systems exchange data. APIs define what requests one system can make to another and what responses to expect.
- REST API: An API style that uses HTTP verbs (GET, POST, PUT, DELETE) over predictable URL endpoints.
- Endpoint: A specific URL on an API where a client sends or receives data.
- Webhook: An HTTP callback that notifies your app when an event happens in an external service.
- CRUD (Create, Read, Update, Delete): The four basic database operations.
- SQL (Structured Query Language): The query language for relational databases. Lovable writes SQL for you, but you can run custom queries in the Cloud SQL editor.
- PostgreSQL: The open-source relational database that powers Lovable Cloud and Supabase.
- Edge function: A serverless function that runs on a globally distributed network close to your users. (Used in both Lovable Cloud and Supabase.)
- RLS (Row-level security): Postgres feature that restricts which rows a user can read or modify based on policies. Critical for multi-user apps.
- Bucket: A storage container for files (images, video, documents) in object storage.
Authentication and security
- OAuth: A protocol that lets users log in to your app using a third-party account (Google, GitHub, etc.) without sharing their password.
- SAML 2.0: An XML-based standard for enterprise single sign-on between an identity provider and a service provider.
- OIDC (OpenID Connect): A modern authentication layer on top of OAuth 2.0, commonly used for SSO.
- IdP (Identity provider): A service that authenticates users, such as Okta, Microsoft Entra ID, Google Workspace, Auth0, JumpCloud, or OneLogin.
- 2FA (Two-factor authentication): A second verification step in addition to a password.
- CORS (Cross-Origin Resource Sharing): A browser security policy that controls which origins can call your API.
SEO and discoverability
- SEO (Search Engine Optimization): Optimizing a site to rank in traditional search engines like Google or Bing.
- AEO (Answer Engine Optimization): Optimizing a site so AI search engines like ChatGPT, Perplexity, Claude, or Gemini surface it as an answer.
- Meta title / Meta description: The page title and short summary shown in search results.
- Canonical URL: The preferred URL for a page, used to avoid duplicate-content issues.
- Sitemap: An XML file listing a site’s pages to help search engines crawl them.
- robots.txt: A file telling crawlers which paths they can or can’t access.
- llms.txt: A newer convention for guiding AI crawlers about a site’s content and policies.
- Open Graph: Meta tags that control how a page is previewed when shared on social platforms.
- Lighthouse: Google’s open-source auditing tool for performance, accessibility, SEO, and best practices.
Design and asset resources
External tools and libraries commonly used with Lovable.- 21st.dev: Open-source React UI components powered by Tailwind CSS and Radix UI.
- Google Fonts: Free, web-optimized font library.
- SVG Repo: Open-licensed SVG icons and graphics.
- Dribbble: Designer community for visual inspiration.
- Noun Project: Library of free icons and stock imagery.
- Typewolf: Curated font pairings and typography inspiration.