This is a documentation-based review. ToolBrain did not run Lovable: no prompts, builds, browser tests, deploys, or purchases. The evidence is Lovable’s pricing page, core docs, testing docs, and changelog, all fetched 2026-11-05. Docs show design intent and guardrails, not practice. The short version: Lovable is designed to finish and documented to check its own work, with a documented manual last mile. End-to-end completion in practice is unverified.
What “Finish the Job” Means for an App Builder
For a beginner, finish is not a pretty preview. In this review, “finished” means the app runs, the backend and database work, authentication works, the project publishes, and integrations get their keys, all without pushing the beginner into manual code or an external console. That is this review’s definition, not a vendor claim. The sources show what Lovable says it will do and where it openly requires a human step. They do not measure how often a real beginner gets stuck at publishing, Cloud setup, or third-party keys. That gap stays open.
What Lovable Says One Build Delivers
Lovable’s core docs say it generates “a working application that includes frontend, backend, database, authentication, and integrations, all backed by editable code” (Lovable docs). The same docs’ quick start aims to “Build and publish your first app in about ten minutes.” Those are the vendor’s claims. This review did not open a generated codebase or time a build, so both are documented, not observed.
Full-stack output, backed by editable code
The docs list frontend, backend, database, authentication, and integrations as one working app. The editable-code part is the exit hatch: the project is not only a hosted black box. The claim is clear; the practice is unverified.
Git sync as the exit ramp
Each project “produces a codebase that can be synced to GitHub, GitLab, or Bitbucket” through Git sync (Lovable docs). That is the clean exit ramp if the app needs work Lovable will not do. The docs support the option; they do not show how clean the first sync is.
The Built-In Safety Net: Tests Lovable Writes and Runs
The testing docs say that when you add or change a rule, Lovable adds a small test for it and keeps it in the project. Before it reports the work as done, it runs the tests that cover the change (Lovable testing docs). The changelog repeats the behavior (Lovable changelog). This is a real guardrail in the design. It is not a guarantee that every build is correct.
What Lovable does not write on its own
Lovable does not write tests for copy, styling, markup, or snapshots (Lovable testing docs). You can ask for frontend tests at any time. Edge tests, direct edge-function calls, and browser testing run only when requested, although the agent may start browser testing while investigating an issue. “Tests pass” therefore does not mean the page looks right or the words are right. The safety net covers rules, not every kind of change.
The toolchains
Frontend tests use Vitest, React Testing Library, and jsdom. Edge tests use the Deno built-in test runner (Lovable testing docs). In new Lovable apps created from May 13, 2026, which use TanStack Start, Lovable also writes tests for backend logic. That is a documented cut-off, not a claim about older projects.
Browser Testing: An On-Request Check
Browser testing lets the agent navigate pages, click buttons, fill forms, and submit requests. It can capture screenshots, console logs, and network activity (Lovable testing docs). The docs say browser testing runs when you request it, though the agent may also start it while investigating an issue. The changelog adds that when Lovable reaches a login screen, it can sign in if the sign-in runs on the built-in Cloud backend. With several users and no choice set, it asks in chat before signing in (Lovable changelog). That sign-in step is not proof that a beginner’s app will publish and work end to end. Browser testing checks a path; it does not remove every manual step after the build.
The 10-Hour Work Window
The changelog says Lovable “now works on every build message for up to 10 hours before it wraps up.” Build messages are billed on the work done (Lovable changelog). A longer window matters for complex requests. The changelog says a large task is more likely to finish in a single message, and that credit check-ins still pause the message at your check-in level. It is a capacity statement, not a quality score, and the docs do not promise that ten hours equals a finished app.
Where the Docs Admit Manual Steps
The strongest evidence is not the feature list. It is where Lovable’s own docs and changelog describe a human step. These are documented seams, not hidden failures. A beginner should plan for them.
Slack: authorize once, publish twice
For Slack apps, a workspace admin “authorizes your Slack workspace once.” Then publish the project, ask Lovable to add it to Slack, and publish once more so the app receives its Slack keys (Lovable changelog). That is a two-publish sequence with a workspace admin or owner authorization in front. It is not one-click.
OIDC sign-in: the button costs a build
OIDC sign-in can be added to a Cloud app with Auth0, Okta, Microsoft Entra ID, or Keycloak. Lovable “then starts a build that adds the sign-in button” (Lovable changelog). It is still a build, so it consumes credits. The docs do not say how often it fails or how much identity-provider setup happens outside Lovable.
Edge functions: tested only when you ask
Edge tests are written only when requested (Lovable testing docs). If a beginner assumes every edge function is covered, they will be wrong. The fix is to ask. The default is not full coverage.
After It Ships: Monitoring and the Database “Resolve” Action
On paid plans, with Visitor analytics enabled, monitoring “checks the errors that happen in your visitors’ browsers,” and the project owner “receives an email about important findings” (Lovable changelog). That is post-ship visibility, which matters because a published app is not finished if it breaks silently. The Cloud database also has a “Resolve” action that checks whether the database is still under pressure, finds the likely cause, and suggests query or code changes (Lovable changelog). A suggestion is not an automatic fix.
Credits: The Fuel That Decides Whether It Gets to Finish
Credits “let you build apps, run deployed apps, and power AI features from one balance” (Lovable pricing). Default Mode credits vary by task complexity. Plan Mode is 1 credit per message. Example costs: “Make the button gray” 0.50 credits, “Remove the footer” 0.90, “Add authentication with sign up and login” 1.20, and “Build me a landing page, use images” 1.70 (Lovable pricing). Those are credit amounts, not prices, and the pricing FAQ says credit value and consumption “depend on your subscription plan and the feature used” (Lovable pricing). This review does not quote plan prices because both pricing captures lacked the plan-tier cards. Check the live pricing page for current plan prices.
Monthly plan credits expire two months after issue. Top-up credits last twelve months. Daily build grants expire at the end of the day. Credits are not refundable (Lovable pricing). The free plan includes a daily grant of 5 build credits, up to 30 a month, plus 20 monthly Cloud credits (Lovable pricing). Those mechanics decide whether a project can keep iterating.
Hosting and ownership
For most users with smaller or new apps, hosting “does not cost anything.” Apps with significant traffic “may start incurring cost on top of the included grant” (Lovable pricing). That is a warning, not unlimited hosting. On ownership, the page states: “You own your code” (Lovable pricing). That pairs with Git sync. This review did not verify either claim in a live account.
Verified vs. Not Verified
The table separates what the sources document from what this run did not check. “Verified” means “stated in a linked source,” not “observed in a hands-on test.”
| Feature | What the sources verify | What is NOT verified this run |
|---|---|---|
| Full-stack generation | Docs say a working app with frontend, backend, database, authentication, integrations, and editable code (docs) | End-to-end run without manual fixes |
| Git sync | Sync to GitHub, GitLab, or Bitbucket (docs) | Clean first sync or conflict handling |
| Rule-based self-tests | Small test per added/changed rule; run before work reported done (testing docs) | How often tests catch real defects |
| Browser testing + self sign-in | Navigate, click, fill, submit; screenshots, logs, network; sign-in on Cloud backend; asks in chat when several users and no choice set (testing docs, changelog) | Coverage of a real publish path |
| 10-hour window | Up to 10 hours per build message; billed on work done (changelog) | That a long window finishes the app |
| Test toolchains | Vitest, React Testing Library, jsdom; Deno runner; TanStack Start backend logic from May 13, 2026 (testing docs) | Coverage quality on a real project |
| Slack flow | One-time admin authorization; publish, add to Slack, publish again for keys (changelog) | How often a beginner needs admin help |
| OIDC | Auth0, Okta, Microsoft Entra ID, Keycloak; build adds sign-in button (changelog) | External identity-provider setup effort |
| Monitoring + Resolve | Visitor-browser errors; owner emails; Resolve checks database pressure and suggests query/code changes (changelog) | Whether alerts are actionable or fixes land |
| Credits / expiry | One balance; complexity-based Default Mode; 1-credit Plan Mode; four example credit costs; expiry rules; non-refundable; free-plan grants (pricing) | Whether the grant is enough for a real project |
| Hosting | No cost for most smaller/new apps; possible cost beyond grant with significant traffic (pricing) | Actual traffic thresholds |
| Code ownership | ”You own your code” (pricing) | License or export details |
| Plan prices | Nothing in this run’s captures; plan-tier cards absent; check live pricing page | All plan prices and billing terms |
The changelog rows come from the same changelog. This is a documentation map, not a test report.
FAQ
Does Lovable test its own work before calling it done?
Yes for rules: a small test is added per added or changed rule and run before work is reported done (testing docs, changelog). Not every change is tested.
Which tests does Lovable not run on its own?
Edge tests, direct edge-function calls, and browser testing run when requested. Lovable also writes no tests for copy, styling, markup, or snapshots (testing docs).
Can it sign into my app while testing?
It can sign in when sign-in runs on the built-in Cloud backend. With several users and no choice set, it asks in chat first (changelog).
How long will it work on one message?
Up to 10 hours per build message before it wraps up; build messages are billed on work done (changelog).
Do credits expire?
Yes. Monthly plan credits expire two months after issue; top-ups last twelve months; daily grants expire at day end. Credits are not refundable (pricing). The free plan includes 5 daily build credits, up to 30 a month, plus 20 monthly Cloud credits (pricing).
Is hosting free?
For most smaller or new apps, hosting does not cost anything; significant traffic may incur cost beyond the included grant (pricing).
Do I own my code?
The pricing page says “You own your code” (pricing). Docs also describe Git sync to GitHub, GitLab, or Bitbucket (docs).
Did ToolBrain actually run Lovable?
No. This is documentation-based. There were no builds, prompts, browser tests, deploys, or purchases. The verdict is about what the sources document.
The Bottom Line
Lovable is designed to finish the job. The docs describe full-stack output, editable code, Git sync, rule-based self-tests that run before work is reported done, browser testing (on request, or when the agent is investigating an issue) with sign-in on the built-in Cloud backend, and a long work window per build message. That is a serious self-checking design.
| Dimension | Score (of 10) | Basis |
|---|---|---|
| Ease | 7/10 | Quick start targets a first app in about ten minutes and the flow is prompt-driven, but documented seams (Slack double publish, OIDC build) add human steps (docs, changelog) |
| Features | 8/10 | Full-stack output with editable code, Git sync, browser testing, post-ship monitoring, database Resolve action, 10-hour work window (docs, changelog) |
| Performance | 5/10 | Self-tests cover added/changed rules only; copy, styling, markup, and snapshots are untested, and edge or browser tests run only when requested. No measured reliability data (testing docs) |
| Docs | 7/10 | Candid testing and credit documentation, but both pricing captures lacked plan-tier cards, changelog entries carried no dates, and three feature URLs returned “Page not found” (testing docs, pricing) |
| Support | not assessed | No support pages were fetched in this run |
| Overall Score | 6/10 | Designed to finish and documented to check its own work, with a documented manual last mile; end-to-end completion unverified |
The overall 6/10 is capped deliberately: this is a documentation-only assessment, and the sources contain no independent completion-rate data. Sub-scores are judgment from the cited sources, not measured results.
It is also documented to have a manual last mile. Slack needs one-time workspace admin or owner authorization and a second publish. Edge tests happen only when asked. OIDC sign-in is a build Lovable starts itself, and that build costs credits. These are stated seams, not hidden failures.
The honest verdict: designed to finish, documented to check its own work, with a documented manual last mile — unverified in practice. Two gaps stay open. Plan prices are not verified this run, so check the live pricing page instead of trusting a number here. And the sources do not measure how often a beginner needs a manual step. A supervised build-and-publish run would be the next useful test.
How This Was Assessed
What we examined
Four sources, all fetched 2026-11-05: the pricing page, the docs welcome/core concepts page, the testing docs, and the changelog. The pricing page was captured twice; both captures lacked plan-tier cards. The changelog text carried no dates per entry, so no changelog dates are used.
What we did NOT run
No hands-on test. No builds, prompts, browser tests, deploys, or purchases. No third-party benchmarks. This review did not open a generated codebase, connect a Git repo, authorize Slack, configure an identity provider, or check a live database. Any practice claim is outside this review. The publish-flow docs were not fetched, so “published” is covered only through the Slack double-publish step.
What would change the verdict
A supervised build-and-publish run would change it most. So would vendor-published success and defect data, a dated changelog, and a pricing capture containing plan tiers. Documentation in areas this dossier does not cover — custom domains, payment setup, secret management — would also fill gaps. Until then, the verdict stays documentation-based.
How This Guide Was Built
This is a documentation-based entry in the weekly Finish the Job series. Sources were fetched 2026-11-05. Both pricing captures lacked plan-tier cards, so no plan prices appear. Three lovable.dev feature URLs returned “Page not found” and were excluded. No hands-on testing: no builds, prompts, browser tests, deploys, or purchases. The goal is to tell a beginner what the docs support, what they admit, and what remains unverified.
📖 Related Reads
- ToolBrain — tool reviews, LLM comparisons, and AI workflow guides
- CodeIntel Log — code quality, debugging, and software engineering benchmarks
Cross-links automatically generated from None.
Back to all posts