The term was coined in February 2025 by Andrej Karpathy, AI researcher and co-founder of OpenAI. It describes a new way of working with AI: instead of writing code, you describe what you want, and AI handles everything else. You see the code but don't read it. You accept changes blindly. You paste error messages into the chat. And somehow, it mostly works.
There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists.
6:17 PM · Feb 2, 2025 · 4M Views
Write in plain language
AI generates working code in seconds
Ship your product without a developer
The tool
Founded in 2023 in Stockholm, Sweden, Lovable is one of Europe's fastest-growing tech companies. Its mission: to be "the last piece of software", a platform where anyone can create a working app through natural language, no coding required.
ChatTrips, a Slovenian startup that built their entire app with Lovable and got invited to Lovable HQ.
Visit chattrips.si →
Lovable benefits everyone involved in building a digital product.
Defines product vision, prioritises features, coordinates the team. Build a prototype without waiting for a developer.
Designs how the app looks and feels. Turn your prototype into a working product, no developer handoff needed.
Builds everything the user sees. Lovable accelerates routine work and generates a solid starting point for complex components.
Builds APIs, authentication, and server-side logic. Lovable Cloud handles the basics so you can focus on what's complex.
Manages deployment and scalability. Lovable auto-deploys, less manual configuration, more time for real infrastructure work.
The person the whole thing is built for. With Lovable, they can now build the tool that solves their own problem, no middleman.
The quality of your prompt determines the quality of your result. These are the battle-tested rules.
Before opening Lovable, answer 4 questions: What am I building? Who is it for? Why will they use it? What is the one key action? Sketch the user journey, every section should have a reason to exist and a reason to lead to the next.
Build a one-page site for [your idea] targeted at [your audience]. The main CTA should be [action]. Focus on a [bold/calm/premium] aesthetic. Ask me any clarifying questions before writing any code.Use a [calm/bold/premium] design. [Color palette], round corners, generous padding. Font: Inter. Overall tone: [adjective].Real project categories, from beginner-friendly to genuinely complex. Every single one built through natural language prompts.
Don't see your idea? Lovable can build almost anything. Start with a description.
Every technical term that comes up when building with Lovable - explained clearly, no jargon.
59 terms
Application Programming Interface. A set of rules that defines how two pieces of software communicate. You send a request to an API endpoint, it does something (fetches data, sends an email, processes a payment) and returns a response.
Almost every Lovable app talks to at least one API, for auth, email, payments, or data.
A unique secret string that identifies your application when making API requests, like a password for software. Never paste it in your frontend code; always store it in secrets/environment variables.
Lovable stores API keys in its secret vault so they're never exposed in the browser.
The process of verifying who a user is, typically via email/password, Google login, or magic link. Once verified, the app knows who is making requests.
Lovable Cloud and Supabase both have built-in auth. One prompt wires up login/logout/session.
A screen width threshold where the layout changes, for example, switching from a 3-column grid on desktop to a 1-column stack on mobile. Standard Tailwind breakpoints: sm (640px), md (768px), lg (1024px), xl (1280px).
Tell Lovable "mobile-first, responsive at all breakpoints" and it applies these automatically.
The process of transforming your source code (React + TypeScript) into optimized static files that browsers can load quickly. Bundlers like Vite handle this.
Lovable uses Vite to build your project. A "build error" means your code has a problem that prevents it from compiling.
Execution mode. Lovable writes code, explores the existing codebase, applies changes across multiple files, and verifies the result. This is the default mode.
Most of your time in Lovable is spent in Build mode.
A conversational mode for analyzing problems, exploring options, and debugging, without making code changes. Use it to understand an error before attempting a fix.
When the "Try to Fix" button loops without resolving an error, switch to Chat mode and ask Claude to analyze the root cause first.
Continuous Integration / Continuous Deployment. An automated pipeline that runs tests and deploys code every time a change is pushed, so new features go live automatically without manual steps.
Lovable's auto-deploy is a simplified form of CD. For more control, connect to GitHub and set up a full CI/CD pipeline.
The AI model made by Anthropic that powers Lovable. Claude is known for being helpful, honest, and particularly strong at writing and understanding code.
When Lovable writes your app, it's Claude doing the thinking. Your prompts go directly to Claude.
A saved snapshot of your code at a specific point in time, with a message describing what changed. Like a meaningful save point in a video game.
Every time Lovable makes changes, it effectively creates a new commit in your project history.
A self-contained piece of UI, a button, a card, a navigation bar. Components can be reused across pages and customized with different content each time.
When you say "build a feature card", Lovable creates a React component.
The maximum amount of text an LLM can consider at once, both your instructions and the existing code. Claude's context window is very large, but very long projects can start to bump against limits.
If Lovable starts forgetting earlier parts of your project, the context window is the reason.
Cross-Origin Resource Sharing. A browser security rule that controls which websites can make requests to your API. A "CORS error" means the server hasn't explicitly allowed your frontend's domain to talk to it.
If your Lovable app gets CORS errors when calling an external API, the fix is usually on the server side or in the edge function.
Lovable's usage currency. Each AI interaction costs credits based on the complexity and length of the prompt and response. Plan mode and Build mode cost credits; the "Try to Fix" button does not.
Precise prompts use fewer credits. The Knowledge Base helps by reducing repeated context.
An organized collection of data stored so it can be queried, updated, and retrieved efficiently. Think of it as a collection of structured spreadsheets that software can read and write to programmatically.
Any app that stores user data, posts, tasks, or settings needs a database.
A controlled, versioned change to your database structure, adding a table, adding a column, renaming a field, or changing a data type. Migrations are scripts that can be run forward (apply) or backward (revert).
Every time Lovable adds a new feature that needs new data, it writes and runs a migration.
The process of making your application live and accessible on the internet, moving it from your development environment to a server where real users can access it.
Lovable deploys your app automatically after every change. You get a live URL instantly.
A view showing exactly what code changed between two versions, additions in green, removals in red. When Lovable makes changes, it shows a diff so you can see exactly what was modified.
Reviewing the diff before accepting changes helps catch unintended modifications to files you didn't want touched.
Document Object Model, the browser's live, in-memory representation of your webpage. JavaScript interacts with the DOM to update what you see without reloading the page.
When Lovable writes code that updates the UI without a page refresh, it's manipulating the DOM.
A small piece of code that runs on a server rather than in the user's browser. Used for tasks that are too sensitive or powerful for the frontend, like calling a third-party API with a secret key, sending emails, or processing payments.
Lovable writes edge functions automatically when a task can't safely run in the browser.
A specific URL where an API accepts requests. For example, POST /api/send-email is an endpoint that sends an email when you call it with the right data.
Lovable generates endpoints (as Supabase edge functions) for tasks that need to run on the server.
A configuration value stored outside your code, like an API key, a database URL, or a feature flag. Accessed by the app at runtime but never hard-coded in the source.
Lovable has a secret vault for environment variables. Never paste API keys into your prompts.
Training an existing AI model further on a specific dataset to make it better at a narrow task, like a customer service bot that's been trained on your company's documentation.
Lovable doesn't use fine-tuning, but it's a common term in the AI app space you'll encounter.
A column in one table that references the primary key (ID) of another table, creating a link between the two. For example, a tasks table has a user_id column that links each task to a row in the users table.
Lovable uses foreign keys to model relationships, posts belong to users, tasks belong to projects.
An animation library for React that makes it easy to add smooth transitions, scroll-triggered animations, and gesture-based interactions.
When you ask Lovable for "fade-in animations" or "smooth transitions", it often uses Framer Motion.
The most popular version control system. Code is stored in a repository (repo), changes are saved as commits, and different versions can exist in parallel as branches.
Lovable projects can be connected to GitHub, giving you full Git history and the ability to edit code outside Lovable.
When an LLM confidently states something that is factually wrong. In coding contexts, this means generating code that looks plausible but references functions, APIs, or libraries that don't exist.
The "Try to Fix" loop in Lovable exists partly to catch and correct hallucinated code before it causes problems.
A function in React that lets components do things like remember data (useState), fetch from an API (useEffect), or share data across the app (useContext). They always start with "use".
Lovable's generated code is full of hooks, they're what makes components interactive.
A syntax that lets you write HTML-like code inside JavaScript. React uses JSX to describe what the UI should look like. It gets compiled into real JavaScript before the browser runs it.
All Lovable-generated components are written in JSX.
JSON Web Token. A compact, signed string that proves who you are after logging in. The server issues it, your browser stores it, and every request includes it so the server knows who's asking.
Supabase auth uses JWTs under the hood, Lovable handles all of this automatically.
A project-level context document in Lovable's settings, a place to describe your project's purpose, tech stack, design system, and rules. Added to every prompt automatically.
A well-written Knowledge Base significantly reduces errors and hallucinations throughout the project.
Large Language Model. An AI trained on massive amounts of text that can generate, summarize, translate, and reason about language. ChatGPT, Claude, and Gemini are all LLMs.
Lovable is powered by Claude, an LLM made by Anthropic. Every prompt you type becomes input to an LLM.
Lovable's built-in managed backend, gives you a PostgreSQL database, user authentication, and file storage with zero configuration, all hosted and managed by Lovable.
For simple apps, Lovable Cloud removes the need to set up Supabase separately.
Model Context Protocol. An open standard created by Anthropic that allows AI models to connect to external tools and services in a standardized way. Lovable uses MCP to integrate with Sanity, GitHub, and other services.
When you connect Sanity or GitHub to Lovable, you're using MCP. It's why Claude can directly interact with external services.
A standard that lets users log in with an existing account (Google, GitHub, Twitter) instead of creating a new password. You've seen it as "Sign in with Google" buttons.
Supabase supports OAuth providers, Lovable can add social login with a simple prompt.
A conversation mode in Lovable where Claude thinks, asks clarifying questions, and proposes an approach, without writing any code yet. Great for complex features or when you're not sure how to structure a prompt.
Use Plan mode first for anything complex. It costs credits but saves many more by getting the plan right before coding.
The text you write to instruct an AI what to do. In vibe coding, your prompt is your specification, the more precise it is, the better the output.
The entire discipline of prompting is about writing instructions that get you the result you actually want.
Short for properties. Data you pass into a component to customize it, like telling a card component what title, image, and description to show.
Lovable uses props to make components reusable.
A question you ask the database, written in SQL. "Give me all tasks where user_id = 42 and status = 'done', ordered by due_date" is a query.
Lovable writes all queries in your data-fetching hooks (like useQuery or Supabase's .from().select()).
Retrieval-Augmented Generation. A technique where the AI looks up relevant documents before generating a response, rather than relying purely on what it learned during training.
Lovable's Knowledge Base feature is a basic form of RAG, your project context is retrieved and added to every prompt.
A JavaScript library for building user interfaces. Instead of writing raw HTML, you build reusable components, like a Lego set for web UIs. Lovable generates all its frontends in React.
Every app Lovable builds runs on React.
A Supabase feature where your app automatically receives updates when the database changes, without needing to refresh or re-fetch. Like a live socket connection to your data.
Use it for live chat, real-time voting results, or collaborative tools. Ask Lovable for "real-time updates" and it adds Supabase subscriptions.
A database that stores data in tables with defined relationships between them. PostgreSQL (which Supabase uses) is the world's most advanced open-source relational database.
Most serious Lovable apps use Supabase's PostgreSQL under the hood.
Building a layout that works well on any screen size, from a 375px phone to a 1920px monitor, by adjusting layout, font sizes, and spacing at different breakpoints.
Lovable builds responsively by default if you prompt for it.
The most common API style. You use standard HTTP methods, GET (fetch), POST (create), PUT (update), DELETE (remove), to interact with resources at specific URLs.
Supabase, MailerLite, Stripe, and most services Lovable integrates with use REST APIs.
Reverting your deployed application to a previous working version after a bad deployment breaks something for users.
Lovable's "Revert" button lets you roll back to any previous state instantly, use it before making risky changes.
A Supabase feature that controls which users can read or write which rows in a table. For example, "a user can only read their own tasks, not anyone else's."
Lovable sets up RLS policies to ensure users can only access their own data.
The structure of your database, which tables exist, what columns each has, what data types those columns accept, and how tables relate to each other.
When you ask Lovable to "store blog posts", it designs and creates the schema automatically.
A period of time during which a user is considered logged in. The session starts when you log in and ends when you log out or the token expires.
Lovable manages sessions via Supabase auth so users stay logged in across page refreshes.
A library of pre-built, accessible UI components (buttons, modals, dropdowns, date pickers) that work with Tailwind. Not installed as a package, the source code lives in your project.
Lovable reaches for ShadCN components automatically, giving you polished UI out of the box.
Structured Query Language. The language used to interact with relational databases, SELECT to fetch data, INSERT to add it, UPDATE to change it, DELETE to remove it.
Lovable writes all SQL for you, but understanding SELECT and WHERE helps you describe queries in your prompts.
Data inside a component that can change over time, like whether a dropdown is open or closed, or the current value of a search field. When state changes, the UI updates automatically.
Lovable manages state so your app reacts to user input.
An open-source backend platform built on PostgreSQL. It gives you a database, user authentication, file storage, and serverless functions, all pre-configured behind a simple dashboard and a JavaScript library.
Supabase is Lovable's default database integration. Connect it with a few values and Lovable writes all the queries.
Hidden instructions that set the AI's behavior before the conversation starts. Lovable has a system prompt that tells Claude how to write Lovable-style code, which tech stack to use, and how to behave.
You can't see Lovable's system prompt, but you can add project-level instructions in the Knowledge Base that function similarly.
A styling system where you apply small utility classes directly in your HTML to control layout, color, spacing, and responsiveness. No separate CSS files needed.
Lovable styles everything with Tailwind, your design prompt translates directly into Tailwind classes.
The unit an LLM processes text in, roughly 3/4 of a word. "Hello world" is 2 tokens. You pay for AI API calls by token count, which is why long conversations cost more credits.
Lovable's credit system is based on token usage. Precise prompts use fewer tokens and cost fewer credits.
A system that records every change made to code over time, allowing you to see what changed, when, and by whom, and revert to any previous state if something breaks. Git is the most widely used version control system.
Lovable has built-in version history. Autosave tracks changes, and you can revert to any previous snapshot.
A point-and-click interface in Lovable for making targeted UI changes, select an element, describe the change, Lovable edits just that component without touching anything else.
Use the Visual Editor for small precise changes instead of rewriting a full prompt. Much faster and safer.
A way for one service to automatically notify another when something happens. Instead of your app constantly asking "has anything changed?", the other service pushes a notification to your URL the moment an event occurs.
Stripe uses webhooks to tell your app when a payment succeeds. Lovable can wire these up.