Lovable hit a milestone this month. Less than two years since launch, it reached $400 million in ARR with 146 employees. Each employee generates close to $3 million in annual revenue. But the most telling number came after that. A Forbes report confirmed the headline figures and added one more line: enterprise customers account for only $20 million of that ARR, about 5%. Out of $400 million, $380 million comes from individual and small-team monthly subscriptions at $20 per person per month.
This is a category that had never been commercially validated before: User-Generated Software. Not “developers becoming more productive with AI,” but “individuals generating software for themselves.”
The concept of User-Generated Software existed before AI. Webflow, Bubble, and Airtable let non-technical people build internal tools and landing pages, but their users still had to understand data structures, workflows, and component relationships. The variable that transformed UGS from “usable by a few” to “usable by anyone” was natural language. When building a CRM becomes as simple as describing what you want, the user base expands from a few million people willing to learn no-code tools to tens of millions who have a need but do not want to learn any tool at all.
Ryan Meadows, Lovable’s CRO, said in an interview that the vast majority of users are non-technical founders, designers, and salespeople who use the tool to build websites, CRMs, inventory systems, and internal tools. Eight million people are using Lovable to turn ideas into running software. This volume does not come from enterprise procurement departments or engineering team budgets. It comes from a large number of individual users paying $20 a month.
Until now, UGS was a theoretical market, a “potentially huge” direction that appeared repeatedly in VC pitches. Lovable, for the first time, turned it into something measurable on a financial statement.
The UGS category is not exclusive to Lovable. Bolt.new is pursuing the same strategy: targeting non-coders, browser-based full-stack generation, monthly subscriptions.
The basic metrics of both companies can be compared side by side. Lovable launched in November 2024, and Bolt.new started around the same time. Lovable went from zero to $400 million ARR in 14 months. Bolt.new’s revenue is not fully public, but third-party estimates put it at around $40 million ARR in early 2025, with a $700 million valuation and over 5 million monthly active users.
The two products have clear differences in approach. Lovable takes a design-first route. Its chat interface includes a detailed planning stage before code generation, producing more polished UI. Its Supabase integration makes databases and authentication completely transparent to users. Visual Edits allow users to drag and modify elements directly in the live preview. Bolt.new takes a code-first route. It is essentially a complete IDE in the browser, with a file tree, terminal, code editor, and multiple model choices, letting users edit code lines directly. It generates faster and iterates faster, but the default interface leans more toward a developer perspective.
A direct comparison using the same prompt on both tools produced an interesting split: Lovable’s output looked like it came from a designer, clean UI and sensible interactions. Bolt’s output looked like it came from an engineer, fully functional and logically correct but visually rougher.
Pricing between the two is nearly identical. Lovable Starter is $25/month, Bolt.new Pro is $20-25/month. Both have free tiers, both use credit or token consumption, and both offer custom enterprise pricing. This symmetry indicates they are targeting the same price-sensitive group: individual users and small teams.
Both are inching toward each other’s territory. Lovable added subagents and Skills in May 2026 to handle more complex parallel tasks, closing some of the functional gap with Bolt. Bolt is adding more user-friendly interaction layers. But the core difference remains: Lovable is better for absolute beginners, Bolt.new is better for people with some technical background who do not want to set up their own environment.
The fact that two companies are growing fast in the same space is the strongest market signal of all. If only one company succeeds in a direction, it might be an outlier. When two grow simultaneously, the demand is real.
But the B2C nature of this category creates a specific tension.
On the Reddit community, one of the most common post titles is “The Problem with Lovable.” The core complaint is uniform: the credit system. The AI claims it fixed a bug, the user burns 10 to 20 credits, and the bug is still there after running. Three times, five times. One post collected dozens of similar experiences. A commenter said: “In my entire career, I never worried about how much it costs to fix a bug. Lovable completely changed that.”
This tension is specific to B2C payment structures. Enterprise Cursor charges per seat annually. AI errors do not inflate the company bill. Claude Code charges per token, but the users are professional developers who can judge whether a task is worth spinning up an agent loop. Only consumer-facing credit pricing makes the user pay for every AI hallucination.
B2B tools absorb uncertainty through contract terms, SLAs, and procurement negotiation. B2C tools have none of these buffers. Errors hit the user’s wallet directly. With 95% of Lovable’s revenue coming from individual users, 95% of its revenue is continuously exposed to this friction.
This tension has produced a consistent community workaround. Almost all experienced users recommend the same path: prototype in Lovable with 30 to 50 prompts, then export to GitHub and continue in Cursor or Claude Code. One community member’s direct words: “Lovable is great to start, but once the project gets big it’s terrifying. Too expensive, and it’s easy to get lost in the changes it makes. It often breaks one thing while fixing another.”
This workflow reveals a fact: in the UGS era, individual users achieve unprecedented efficiency from idea to interactive prototype. But the segment from prototype to maintainable system still flows toward B2B developer tools. There is a gap between B2C pricing and B2B payment structures that has not yet been filled.
Comparing Lovable and Cursor reveals differences along two axes. The horizontal axis is the target user: non-technical or professional developer. The vertical axis is the business model: B2C or B2B.
Cursor derives 75% of revenue from enterprise customers, with an annualized ARR of $4 billion. Claude Code’s $2.5 billion run-rate is more than half from large enterprise contracts paying over $1 million annually. This is B2B times professional developers. What it sells is efficiency improvement, and the buyer has budget, evaluation capability, and contractual protection.
Lovable and Bolt.new are B2C times non-technical users. What they sell is not efficiency but the ability to create from zero to one. The buyer has no technical evaluation capability, no procurement department to negotiate, and often no idea whether the purchased product can survive in production. This difference is not a matter of market segmentation. It determines the entire product design, pricing strategy, and growth model.
The moat of B2B tools is deep workflow integration. Replacing Cursor means replacing the entire daily development environment, from keyboard shortcuts to project setup. The moat of B2C UGS tools is that users do not know alternatives exist. A designer who built her first CRM in Lovable does not know what Bolt.new is and does not care. She only knows she built something that runs, and did it without writing a single line of code. Brand awareness and first-experience lock-in matter more than feature depth in this population. At the same time, once users learn enough to recognize tool limitations (credit consumption, code maintainability), switching costs are low because there is no engineering workflow to migrate. She never had one.
This is why user growth numbers for UGS tools and professional developer tools are not comparable. Lovable has 8 million users, Replit 40 million, Bolt.new 5 million monthly actives. Cursor is at 1 million plus. In absolute user count, B2C UGS tools far exceed B2B developer tools. But per-user revenue is the opposite: Cursor’s $40 per month enterprise contract versus Lovable’s $20 per month individual subscription. ARPU differs by an order of magnitude.
In April last year, I wrote a survey on self-trained models in AI coding tools. The conclusion was that no independent coding tool relying purely on API calls had crossed $100 million ARR. Lovable shattered that conclusion. Its moat is not at the model layer but at the encapsulation layer: template constraints, security scanning, version recovery, one-click deployment, infrastructure hosting. The model is just one component.
The earlier judgment failed because it only considered the B2B developer tools quadrant. In that quadrant, self-trained models are indeed the only known moat. Cursor’s Composer model and Cognition’s self-developed agent models both prove this. But UGS is a different business. Its competitive barrier is not “who generates more correct code” but “who lets users complete the journey from idea to running software with the lowest cognitive burden.” That is the work of product encapsulation, not the model vendor’s work.
This in turn explains why Anthropic and OpenAI are building B2B developer tools and supplying models but have not entered UGS themselves. Anthropic showcases Lovable on its marketplace rather than building a competing product. Enabling non-coders to build software requires a different product DNA than building developer tools for large language model companies. It is not a capability gap. It is an attention allocation problem.
UGS is not a trend that replaces B2B tools. It is a parallel category. Two types of tools serve two types of people, solve two types of problems, and earn two types of money. But there is dynamic tension between them.
If UGS tools can narrow the prototype-to-production gap sufficiently through templates and validation mechanisms, they could evolve from entry points to destinations, and B2C users would no longer need to export to B2B tools. Conversely, if Cursor or Claude Code builds a no-code entry mode, they could sink into UGS territory. The boundary is not static.
But at this moment, the most important finding is that UGS now has evidence on a commercial ledger. Before, we could only say that “individuals generating software for themselves” is a potentially huge market. The revenue numbers that Lovable and Bolt.new ran up in 14 months turned “potential” into “validated.” That is the most informative part of the $400 million ARR.