Somewhere between March and August 2026, "AI app builder" pricing pages quietly became the least readable part of the entire category. Every vendor bills in some flavor of usage unit — credits, tokens, "effort" — and every vendor insists its version is the simple one. Lovable, the prompt-to-app builder that has spent the last two years racing Bolt.new, v0, Replit Agent, and Base44 for the same non-technical-founder wallet, just shipped the clearest test case yet of whether that's true. On June 13, 2026, it announced it was collapsing two separate account balances — one for building an app, one for running it in production — into a single pool of credits. The framing was pure simplification: one number, one dashboard, nothing to reconcile.
Read the documentation that shipped alongside it, though, and the picture is messier than the announcement post lets on. The balance is unified. The rules governing what's inside it are not. Four different credit types, three different expiry clocks, and a handful of usage grants that still don't roll over are all sitting under that single number, and as of the most recent changelog entries, the rollout itself is still gradual enough that not every workspace sees the same experience yet. This is worth a closer look not because Lovable did something uniquely bad — it's a genuinely useful change — but because it's a clean specimen of a pattern every developer evaluating one of these tools is going to run into: the sticker price is never the real price, and "we simplified billing" rarely means what it says.
What actually happened
Until this update, a paid Lovable workspace carried two separate balances. Your monthly subscription bought you build credits — the currency for generating, editing, and updating an app inside the editor. Once that app went live, a completely separate Cloud and AI balance, denominated in dollars, paid for everything the running app needed: database reads, authentication, file storage, server functions, and any AI-gateway calls the app itself made at runtime. Two ledgers, two mental models, two places to run out of money.
Lovable's announcement post says the split made sense when Lovable Cloud and Lovable AI first launched, because it mirrored how people were used to buying software — pay to build, pay separately to host. But as workspaces started shipping real production apps — the post cites Klar's AI study agent serving 6,000+ students and WeGlow's nonprofit tooling as examples — the line between "building" and "running" blurred, and reconciling two balances with two different units (credits vs. dollars) became busywork nobody asked for.
The fix: one balance, spent across both building and running, with the old Cloud/AI dollar balance converted into credits at the workspace's plan rate during migration. According to the credits and usage documentation, this is still rolling out gradually — some workspaces were, as of early August, still on the old two-balance experience. Alongside the merge, Lovable shipped three related changes worth knowing about even if you never touch the billing page:
- Pause instead of fail. If a workspace runs out of credits mid-message, the build no longer just stops. A card appears in chat offering to top up and resume exactly where the run left off, or to let Lovable wrap up the current step and halt cleanly instead of starting new work. There's no deadline — paused work waits indefinitely.
- Credit check-ins (beta). For long-running messages, Lovable can now pause when a single message crosses a spend threshold (20 credits by default) and show you the running cost before continuing. It's a soft cap, not a hard one — a run can overshoot the threshold slightly before the check-in fires — and you can raise the level or disable it per account.
- Natural-language usage queries. You can now ask Lovable directly about your workspace's credit spend rather than digging through the dashboard.
None of these are dramatic on their own. Together, they read as a company that got enough support tickets about surprise bills to build real guardrails around them — which is itself a useful signal about how this category actually gets used in practice.
How the credit system works now
This is the part the "one balance" headline glosses over. Open Settings → Plans & credit usage on a migrated workspace and you'll find not one credit type but four, each with its own expiry rule:
| Credit type | Source | Expiry |
|---|---|---|
| Monthly credits | Included with your plan, issued each billing cycle | 2 months after issue (monthly billing) or 1 month after the annual period ends (annual billing) |
| Rollover credits | Unused monthly credits carried forward | Same window as monthly credits |
| Bonus credits | Support grants, referrals, affiliate programs | Varies |
| Top-up credits | One-time or auto top-ups | 12 months after purchase |
On top of those four, three separate usage grants exist entirely outside the rollover system: a daily build grant (5 credits/day, resetting at 00:00 UTC, capped at 30/month on the Free plan), a monthly Cloud grant (20 credits), and a monthly AI grant (4 credits). None of the three roll over — an unused Tuesday's build grant is simply gone by Wednesday. When you spend, Lovable burns the soonest-expiring general credits first, which is sensible design, but it means the "one balance" you see in the dashboard is a rendered summary of at least seven different underlying rules, not a single pool with one behavior.
The other thing the unification doesn't touch: how much a given action costs. Per a detailed teardown from DVNC Agency, Plan Mode messages run 1 credit flat, but Build Mode is priced per action — making a button gray costs roughly 0.5 credits, removing a footer 0.9, wiring up authentication with sign-up and login 1.2, and generating a landing page with three AI images and five sections 1.7. That variance is normal for how LLM-driven builders work — a landing page with generated imagery genuinely costs more compute than toggling a color — but it means budgeting "100 credits a month" as "100 things I can do" is wrong by a wide margin depending on what you're building. AxonBuild's analysis, last verified against the docs on August 5, 2026, puts it plainly: this is "three clocks, not one" — a daily reset, a period-end expiry for grants, and a rolling multi-month window for plan credits, all coexisting in the same account.
What changed vs. the rest of the category
None of this makes Lovable an outlier — it makes it typical, which is the more useful observation. Every serious competitor in the prompt-to-app space has its own version of the same problem, and comparing them side by side is where the unification actually earns some credit (pun intended), because Lovable's model, warts and all, is one of the more legible ones on the market.
| Tool | Meters usage in | Entry paid plan | What can blow up your bill |
|---|---|---|---|
| Lovable | Discrete credits (build + Cloud + AI, unified) | $25/mo (Pro, 100 credits) | Image-heavy generations, complex Build Mode actions |
| Bolt.new | Tokens | ~$25/mo (10M tokens) | Large projects — the whole file tree gets re-synced to the model on every message |
| v0 | Credits derived from tokens | $20–30/mo (per user) | Vercel's own hosting costs stack on top, separately |
| Replit Agent | Effort-based (time + compute per task) | $20/mo ($20 of credits) | Autonomous debugging loops — Agent 3 can run up to 200 minutes unsupervised |
| Base44 | Two credit types: message (build) + integration (runtime) | $16/mo (Starter) | Integration credits are charged every time a live app sends an email, calls an LLM, or generates an image |
Two of these deserve a closer look, because they show what "worse than Lovable's version" actually looks like in production. Replit's effort-based pricing is the most honest in theory — you pay for what a task actually costs — and the least predictable in practice. A widely cited incident, reported by Altar.io and corroborated independently by Dreaming Press, has a founder burning $607 in overage charges within days of subscribing, and multiple other users reporting single debugging sessions costing $45 to $350 above their plan's included credits. The mechanism is structural, not a bug: Agent 3's ability to run autonomously for up to 200 minutes and spawn sub-agents is exactly the capability that lets a stuck debugging loop keep spending without anyone noticing until the invoice arrives.
Base44 — acquired by Wix in June 2025 for roughly $80 million and run since as a semi-independent product — has arguably the worst-shaped incentive of the five. Its integration credits meter runtime usage: every email, every generated image, every LLM call your shipped app makes in production burns credits, and unlike Lovable's rollover credits, none of Base44's credit types carry over. HowAIWorks.ai puts it bluntly: it's a pricing model that "punishes success," since the more real users your app has, the faster you burn integration credits, with no cheaper steady-state once you've built the thing. Base44 also carries a 2.4/5 Trustpilot rating in Altar.io's reporting, with the most common complaint pattern being AI-generated code that breaks under real use, credits spent asking the AI to fix it, and the bug persisting anyway — a failure mode that isn't unique to Base44 but is made more expensive by its billing shape.
Against that field, Lovable's unified balance is a real improvement, not a cosmetic one: build costs and running costs compete for the same pool, so a workspace can see total cost of ownership in one place instead of reconciling a credit ledger against a dollar ledger by hand. That's a genuine reduction in operational overhead for anyone managing more than a hobby project. It's just not the reduction in underlying complexity the announcement post implies — the rules didn't get simpler, they got centralized.
Where this fits architecturally
It's easy to read "credits" as an arbitrary abstraction bolted on top of a normal cloud bill, but the unification only makes sense once you see what a Lovable app actually is under the hood. A generated app isn't just static frontend code — it ships wired into Supabase for its database, auth, and file storage, and into a Lovable-operated AI gateway for any in-app AI features (the changelog notes the gateway's default model recently moved from Gemini 3.6 Flash to Gemini 3.7 Flash for apps that don't pin a specific model). Before the merge, that meant a workspace's spend was split across three genuinely different cost centers — LLM calls to generate code, Supabase-shaped infrastructure costs to run the result, and separate AI-gateway calls the shipped app makes at runtime — collapsed into two visible balances that didn't map cleanly onto either. The new single balance doesn't change what's being metered underneath; it changes the accounting layer sitting on top of it, converting three cost centers into one spendable number while preserving (and now surfacing) which of the three consumed it. That's the right instinct architecturally — the alternative, tried by nobody in this category yet, would be flat infrastructure pricing decoupled from generation activity entirely, which none of these vendors can currently afford to offer given how directly their margins depend on LLM token costs.
Practical use cases where this actually changes behavior
The unified balance matters most in three concrete situations. An agency running client work through one Lovable workspace can now see, per project and per team member, whether a client's monthly retainer is being eaten by build iteration or by that client's live app's database and AI usage — previously an exercise in cross-referencing two separate statements. A team on the Business tier evaluating whether to move a side feature's AI calls in-house versus staying on Lovable's AI gateway now has a single number to compare against a self-hosted alternative, rather than having to separately estimate build-time and run-time costs. And anyone who has hit the old failure mode — a build silently stalling because the Cloud/AI dollar balance ran dry while the separate build-credit balance still had room — gets the new pause-and-resume flow instead, which is a meaningfully better failure state than a broken deploy nobody notices until a user reports the app is down.
Where it changes nothing: solo prototyping. If you're on the Free tier building a single public project to test an idea, you were never juggling two balances in any way that mattered, and the unification is invisible to you. The people who benefit are, unsurprisingly, the people spending enough to have needed a spreadsheet before.
Why this actually matters for developers, not just founders
It's tempting to read all of this as a solo-founder problem — "just budget more credits" — but the credit-metering pattern has three effects that scale badly the moment a real team or a real customer base gets involved.
Cost forecasting breaks at the point these tools are most useful. Every comparison piece surveyed for this article — AIToolPick, ProductOS, DVNC, Dreaming Press — converges on the same warning: the plan price is a floor, not a ceiling, because none of these vendors charge a flat rate for what a "feature" costs. A landing page redesign might run 1.7 credits or 17, depending on how many images get generated and how many revision rounds it takes to get right. That's fine for prototyping. It's a genuine planning problem the moment you're trying to give a client, a manager, or a budget owner a number before starting work — something developers coming from fixed-scope estimation are not used to having to hedge against.
Team pricing shapes differ enough to matter at headcount. Lovable's Business plan shares one credit pool across unlimited seats at $50/month; Bolt scales per-user at $30/seat; v0's Business tier runs $100/user/month; Replit's Pro tier is a flat $100/month for up to 15 collaborators — the cheapest team math in the category by a wide margin, per AIToolPick's breakdown. A three-person team evaluating these tools on sticker price alone will land somewhere very different depending on whether they read "team pricing" as per-seat, flat, or pooled.
Lock-in is a billing question as much as a code-export question. This is where Lovable's positioning is genuinely stronger than it gets credit for. Code export via GitHub sync is full and unrestricted, matching Bolt and v0 and beating Base44 outright — Base44 only exports the frontend, leaving auth, business logic, and API endpoints bound to its proprietary backend SDK, confirmed independently by both HowAIWorks.ai and Altar.io. If a Base44 app takes off, migrating off the platform means rewriting the backend, not just cloning a repo. Lovable's credit rollover and unified balance don't change that calculus for anyone else in the category, but they do mean that if you do stay on Lovable, understanding what you're actually paying for is at least tractable — which is not nothing, given how opaque the alternatives are.
What the marketing leaves out
Three things worth knowing before you take "we simplified billing" at face value:
First, the rollout has been gradual since June, and as of the documentation's most recent revision, some workspaces are still on the legacy two-balance system. If you're evaluating Lovable right now, don't assume the pricing page or a colleague's dashboard matches what you'll see — check your own workspace's Plans & credit usage page directly.
Second, the credit check-in feature — the one piece of the update genuinely aimed at preventing bill shock — is beta, off by default in the sense that it only triggers past a threshold you can raise or silence, and it's a soft pause, not a hard stop. A determined runaway generation can still overshoot before the check-in fires. It's a meaningfully better guardrail than Replit or Base44 offer, but "meaningfully better than a category with no guardrails" is a low bar.
Third, the "your plan price isn't changing" line in the announcement is true and slightly beside the point. The price didn't move; what moved is how legible your spend is and how many separate rules govern it. Anyone reading the blog post as "billing got easier" without reading the docs page will be surprised the first time a top-up credit expires on a 12-month clock while their monthly credits expire on a 2-month clock in the same balance.
Who should actually care
If you're already running a production app on Lovable Cloud, this is a clear win — you get one dashboard instead of two, per-model cost visibility you didn't have before, and a pause-and-resume flow that beats hard-failing mid-build. Migrate when your workspace offers it and read the Usage Details tab once to understand where your spend actually goes; most teams underestimate how much of it is Cloud/AI runtime versus build-time generation until they can see it broken out.
If you're evaluating which of these five tools to start with, the credit-vs-token-vs-effort question should weigh more heavily than the sticker price. Teams that iterate in short, predictable sessions do fine with any of them. Teams that expect long agentic runs — multi-step refactors, autonomous debugging, anything that could plausibly run unattended for tens of minutes — should treat Replit's effort-based pricing as a real cost risk, not a footnote, given the documented $45–$607 overage range. Anyone building something with real customers and any chance of wanting to leave the platform later should weight Base44's backend lock-in heavily against its lower sticker price.
If you're a solo developer or small agency building disposable prototypes and immediately exporting to your own stack, none of this billing architecture matters much — Bolt's generous free tier and instant browser-based iteration will get you there faster, and you'll be gone before the credit clocks matter.
The honest read
Lovable's update is a real, useful piece of engineering — consolidating two billing systems that grew organically into one coherent data model is not trivial, and the visibility improvements (per-model spend, per-project breakdown, per-person usage on team plans) are things every competitor in this list should be shipping and mostly isn't. But "simplifying billing" and "simplifying the number you see" are different claims, and the gap between them is exactly where developers get burned across this entire category — not just at Lovable. Four credit types and three non-rolling grants under one balance is progress over two ledgers in two currencies. It is not the same thing as one rule.
The deeper pattern this exposes is that "credits" as a unit has become a way for an entire product category to avoid saying "we don't know what this will cost you until you run it" out loud. Lovable said it more honestly than most, with real guardrails attached. That's worth crediting. It's also worth not mistaking for the problem being solved.
What's your experience been budgeting for one of these AI app builders in a team setting — has usage-based credit pricing ever actually surprised you the way per-seat SaaS pricing never did, and if so, what changed how you scoped work around it afterward?
Sources:
- We're simplifying how billing works on Lovable
- Lovable changelog
- Credits and usage — Lovable docs
- Lovable Credits Explained (2026): Resets, Rollover, Real Cost — AxonBuild
- Lovable vs Bolt vs v0 vs Replit vs Base44 — Altar.io
- Best AI App Builders Pricing 2026 — AIToolPick
- Base44 vs Lovable vs Bolt vs Replit — DVNC Agency
- Best AI App Builders in 2026 — HowAIWorks.ai
- AI app builder pricing compared (2026) — ProductOS
- Lovable vs Bolt vs v0 vs Replit: Choosing an AI App Builder in 2026 — Dreaming Press
Top comments (0)