Docs

Glossary

about 1 minFirst appchecked 19h agoOfficial page

The short version

This page is a dictionary of words and phrases used in Lovable, split into terms specific to Lovable and general development concepts. It helps you understand what different features and ideas mean when you see them in the documentation.

Anyone using Lovable needs this to understand the language used throughout the platform and its documentation.

Words decoded

Chats: Conversations you have with Lovable outside of your specific projects, like a general brainstorming session or asking questions about your apps.
Chat mode: A setting in your project chat where Lovable talks about your app without changing its code, useful for discussions and planning.
Chat usage: How much you use Lovable for conversations, including messages in general chats, chat mode, and through integrations like Slack or Telegram.
Project chat: The main area in the Lovable editor where you interact with Lovable about a specific app, choosing between Chat, Plan, or Build modes.
Daily chat allowance: A set amount of chat messages you can send each day for free, included with your Lovable plan, before other credits are used.
Voice conversation: A live, spoken conversation you can have with Lovable, where you talk back and forth, different from just dictating text.
Build mode: The setting where Lovable actively makes changes to your project's code, runs tests, and applies updates.
Plan mode: A setting where Lovable helps you explore your project and create a plan for changes without actually modifying any code.
Subagents: Temporary, read-only assistants that Lovable creates to help research or review specific parts of a task without changing your project.
Prompt: A natural language instruction you give to Lovable, telling it what you want to create, change, fix, or understand in your app.
Follow-up: A message you send to Lovable while it's still working on a task, to guide its progress or add new instructions.
Message queue: An older system (now replaced by follow-ups) where your messages would wait in line and be processed one by one while Lovable was busy.
Diff: A side-by-side comparison that shows exactly what changes Lovable made to your files.
History: A record of all the changes made to your project over time, allowing you to go back to previous versions.
Visible tasks: A step-by-step display that shows you what Lovable is doing in real-time when it's building something, including which files it's touching.
Workspace: A shared online space where you and your team build apps together, holding all your projects, members, and billing information.
Workspace admin settings: The central place where owners and administrators manage all the settings for their workspace, like who can access what, billing, and security.
Project: A single app you are building in Lovable, with its own code, chat history, and settings, always part of a workspace.
External collaborator: Someone who can access a specific project in your workspace but isn't a full member of the workspace itself.
Project access: The setting that controls who can view and edit your project in Lovable, either everyone in your workspace or only specific people.
Restricted project: A project that can only be seen and edited by people you specifically invite, even if they are in the same workspace.
Share dialog: A pop-up window where you can invite people to your project, manage their roles, get invite links, or create links for others to preview your app.
Groups: Named collections of workspace members that make it easier to give access to multiple projects or folders at once.
SSO (Single sign-on): A system that lets you log into Lovable using your company's existing login details (like from Okta or Google Workspace), so you don't need a separate password for Lovable.
Domain lock: A combination of settings that ensures everyone from a specific company email domain logs into Lovable using their company's SSO and can only work within their company's workspaces.
SCIM provisioning: A connection that automatically manages user accounts and groups in your Lovable workspace based on changes in your company's identity provider.
Audit logs: A detailed, searchable record of all actions taken within your workspace, showing who did what, when, and to which resource.
Insights: A dashboard for workspace administrators that shows how much Lovable is being used, including visits, active apps, and active builders.
Preview: A live, interactive view of your app within Lovable that updates as Lovable builds, letting you see and interact with it like a user would.
Preview toolbar: A bar at the top of the app preview that lets you select parts of your app, edit text directly, draw notes, and leave comments.
Code editor: The part of Lovable where you can view and manually change your project's underlying code.
Knowledge: Instructions and information that Lovable remembers across different conversations, either for the entire workspace or for a specific project.
Skills: Reusable sets of instructions or 'playbooks' that Lovable can follow for common tasks, either by your command or automatically.
Cross-project referencing: A way to use code, files, or chat history from another project in your workspace, so you don't have to rebuild things from scratch.
File generation: Lovable's ability to create and provide downloadable files (like PDFs or Excel sheets) directly in the chat, without changing your app's code.
Browser testing: A tool where Lovable simulates a user interacting with your app in a real web browser to check if everything works as expected.
Testing tools: The overall set of features for checking your app, including browser testing, frontend tests, and tests for backend functions.
Drafts: Separate copies of your project where you can make changes and experiment without affecting the main project, until you decide to apply or discard them.
Remix: Creating a new project by copying an existing one, allowing you to build something new based on it while keeping the original project untouched.
Design guidance: A step before Lovable starts building, where it might show you different visual options or ask questions about how you want your app to look.
Design directions: Three different visual examples (like website layouts) that Lovable can show you before building, so you can pick your preferred style.
Design systems: A feature that lets you define a collection of reusable design components and rules in one Lovable project, which other projects can then use.
Design templates: Pre-approved Lovable projects that you can use as a starting point for new apps, copying their entire structure and design.
Hosting: Lovable providing the online space and infrastructure for your published app to be available to users, including a public web address and security.
Publish: The action of making your Lovable project live and accessible to the public via a web address.
Website access: The setting that controls who can visit your live, published app, such as making it public, only for your workspace, or for specific invited people.
Custom domain: Using your own web address (like 'yourcompany.com') for your published Lovable app instead of the default Lovable address.
Transfer a domain: Moving a web address you already own from another provider to be managed directly by Lovable.
Branded app URLs: Customizing the web addresses for all apps in your workspace to include your workspace's name, making them more recognizable.
Analytics: Built-in tools that show you how many people visit your published apps and how they interact with them.
SEO and AI search (AEO): Features that help your app appear higher in search engine results (SEO) and be easily found by AI-powered search tools (AEO).
Lovable Cloud: Lovable's all-in-one service that hosts your app and provides a built-in backend with database, storage, authentication, and other features without needing external setup.
Database: An organized storage system for your app's information, like user accounts or product lists, which you can view, edit, and back up.
Storage: Online space for your app's uploaded files, such as images or documents, which are private by default but can be shared securely.
Jobs: Automated tasks that run in the background of your app's backend at scheduled times, like sending daily summary emails.
Logs: A searchable record of everything that happens in your app's backend, useful for troubleshooting and understanding its activity.
Project usage: A view that shows you the costs associated with your project's hosting and backend services, broken down by category.
Advanced settings (Cloud): Settings for the technical infrastructure of your app's backend, such as its processing power, storage space, and options to export or pause it.
Edge functions: Small pieces of code that run on Lovable's servers to handle your app's behind-the-scenes logic, like processing payments or managing webhooks.
Secrets: Securely stored sensitive information (like API keys) for your project that your backend code can use without exposing them in the browser.
Build secrets: Workspace-wide sensitive information (like tokens for private software packages) that Lovable automatically provides when your projects are being built.
Email auth: A way for users to sign into your app using their email address and a password or a one-time code.
Phone auth: A way for users to sign into your app using their phone number and a one-time code sent via text message.
Google auth: Allowing users to sign into your app using their existing Google account.
Apple auth: Allowing users to sign into your app using their existing Apple account.
SAML SSO (apps): A system that lets your app's end-users sign in using their company's identity provider (like Okta), configured specifically for your app.
Lovable workspace identity reuse (apps): A feature that automatically recognizes logged-in Lovable workspace members when they use apps built within that workspace, without needing a separate login.
Custom emails: Sending authentication and app-related emails from your own domain, which helps ensure they are delivered reliably.
Payments: Built-in features for handling subscriptions and one-time payments in your app, powered by services like Paddle or Stripe.
Security overview: A summary of Lovable's built-in security features, including scans, protection for sensitive keys, and checks for vulnerabilities.
Quick scan: A fast security check of your app's database and other components that runs every time you publish, without using up your credits.
Deep scan: A thorough security review of your app's code to find harder-to-detect vulnerabilities, which can be run manually for free or scheduled for a small credit cost.
Security view: A tab for each project that displays the results of security scans, findings about dependencies, and recommendations for improving security.
Security center: A central dashboard for your entire workspace that brings together all security findings, scan coverage, and risks across all your projects.
Security insights: A view within the Security center that combines various security data points to help you prioritize which projects need security attention.
Privacy & security settings: Workspace-wide controls for managing default project access, publishing permissions, and protecting sensitive data.
App + chat connectors: Connections to external tools (like Notion or Jira) that Lovable uses both when you're building in the chat and when your published app is being used by others.
App user connectors: Connections where each user of your published app links their own account (e.g., their personal Gmail), so the app works with their specific permissions and data.
Chat connectors (MCP servers): Personal connections to your own accounts in external tools (like Notion or Jira) that give Lovable context in the chat while you build, but are not part of your published app.
Custom connector: A connection to any external service (API) that a workspace administrator creates, allowing members to use it like any other built-in connector.
Lovable MCP server: A special server that allows other AI tools (like ChatGPT) to programmatically build, change, and deploy Lovable apps.
Lovable API: A way for your own scripts and services to interact with Lovable programmatically, managing projects, settings, and security scans.
Lovable API connector: A connection that allows an app you build with Lovable to call the Lovable API for a connected workspace, with the API key securely stored by Lovable.
API keys (access tokens): Secure keys that authenticate requests to the Lovable API, managed in your workspace settings with specific permissions and expiry dates.
Lovable AI: Built-in artificial intelligence features you can use directly in your published apps for things like chatbots, summaries, or image generation, without needing your own AI keys.
Build with URL: A method to create Lovable apps by providing instructions and images through a web address, useful for sharing pre-filled prompts.
Lovable desktop app: A dedicated application for your computer (macOS and Windows) that offers enhanced project management and local integration features.
Lovable mobile app: A companion app for your phone or tablet that lets you build and review Lovable projects on the go.
Supabase: An open-source alternative to Lovable's built-in backend services, which you can connect to your Lovable projects.
Git sync: A two-way connection between your Lovable project and a Git repository (like GitHub), allowing for version control and team collaboration on code.
GitHub integration: Connecting your Lovable project to a GitHub repository for version control.
GitLab integration: Connecting your Lovable project to a GitLab project for version control.
Bitbucket integration: Connecting your Lovable project to a Bitbucket Cloud repository for version control.
Credits: Units used by Lovable to measure and pay for various services, including building apps, hosting, running backend services, and AI features.
Credit top-up: An option to buy extra credits beyond your monthly plan, either as a one-time purchase or automatically.
Daily build credits: Credits granted each day for building your app, and for chat usage after your daily chat allowance runs out.
Usage-specific grants: Credits that are specifically for one type of usage (like chat or building) and are used before your general credits.
General credits: Credits that can be used for any Lovable service after your specific grants have been used up, including monthly plan credits and top-up credits.
Rollover credits: Unused monthly credits from a previous billing period that are carried forward, but they still have an expiration date.

The short version, steps, decoder and prompt on this page are written automatically from Lovable's own documentation and can lag or misread it. The official page is always the authority.