Skip to content
vibe coding

Four AI-Built Apps, 137 Exploitable Flaws: What Astra's Pentest Means for Your Lovable App

Astra pentested four AI-built apps and found 137 exploitable flaws. What it means for your Lovable or v0 app — and the 10-minute check to run tonight.

By Lynxwell Digital November 16, 2026 12 min read
Four AI-Built Apps, 137 Exploitable Flaws: What Astra's Pentest Means for Your Lovable App

Astra Security gave four AI coding platforms — Emergent, Lovable, Replit and Base44 — one identical, security-explicit prompt to build the same app, then pentested all four builds. The result: 137 confirmed, exploitable vulnerabilities across the four apps. The Lovable build alone shipped 27 of them, including a login bypass and a flaw that let any logged-in account read 811 user profiles. If your app was built the same way, it probably carries the same classes of flaw — and the fix starts with a 10-minute check you can run tonight, not a rebuild.

What Astra actually tested

The study, published November 2, 2026, is worth taking seriously because of how it was set up. One identical prompt, given to all four platforms with no advance notice to the vendors. The prompt described a FastAPI user-management microservice and named real controls — bcrypt hashing, JWT tokens, parameterised queries, rate limiting, configurable CORS, a four-tier role model. Three coordinated AI agents — a Structured Pentest, a Bug Bounty Hunter and a Validator — attacked each build in parallel, followed by human review. Nothing counted until it cleared an exploitability bar requiring reproducible evidence of real impact.

That setup answers the usual objection to "AI code is insecure" stories — cherry-picking. The prompt was the same, the test was the same, the counting bar was the same. And the gaps were more consistent than the code: nine CWE-mapped vulnerability classes account for most of the 137 findings, and five of those classes appeared in every build, regardless of stack, framework or auth strategy.

One plain disclosure: Astra sells the pentest service its study recommends, and it was named best autonomous pentesting tool of 2026 by CIO Times on November 13, 2026. The counterweight is the method — every finding was re-exploited by a validator agent and reviewed by a human engineer before it was counted.

What the Lovable build shipped

Astra published the Lovable numbers openly, so those are the ones we can quote. The Lovable-built app carried 27 confirmed, exploitable vulnerabilities: 5 High, 18 Medium and 4 Low, with no Critical findings, and every raw finding passed vetting without a single rejection.

The High findings are the ones that should make a founder sit up:

  • Broken access control exposed 811 user profiles to any authenticated account. Not an admin, not a hacker — any logged-in user could read other users' profiles.
  • An MFA bypass where the password alone was enough.
  • Exposed role and admin data, an unauthorized Supabase channel, and session tokens that stayed valid after logout.
  • Weak cookie flags and user enumeration rounded out the list.

Note what Astra did not test: Lovable's own platform, editor and infrastructure. The app tested is the generated code plus the Supabase backend Lovable wires up for you. The risk sits in your app, not in Lovable's servers — which is why it is your problem to fix. With Lovable nearing 8 million users by late 2025, a lot of people are shipping builds shaped like the one tested. Security is only one of the things that breaks when an AI-built app meets real users — the rest of the failure modes are just as predictable.

The five flaws in every build

The most useful number in the whole study is not 137. It is 66: the five weakness classes that showed up in all four builds account for 66 of the 137 confirmed findings, and Astra classifies all five as low-complexity, config-level fixes with a single root cause — a prompt that under-specified a known control.

  • CORS misconfiguration was the single most common finding, with 16 confirmed instances, and one platform's build alone accounted for more than half of them. Every app reflected arbitrary request origins back in Access-Control-Allow-Origin while allowing credentials, letting any external website make authenticated requests on behalf of a logged-in user and read the response.
  • JWT session handling, broken access control, token storage and user enumeration account for 39 findings between them, each appearing in three of the four apps.

The severity picture is lopsided in a way that matters for triage. All 13 Critical findings in the study cluster in authentication and authorisation on a single app, and most of the 14 High findings are broken access control. The hardened prompt closes the broadest category; the most severe category lives in how the generator implements auth — the difference between "ask better" and "check the running app."

How mediums become a takeover

Each finding on its own would mostly be filed as medium or low. Chained together, they hand over the user table. Astra's typical attack chain ran like this: CORS reflected any Origin header back as allowed, the API accepted credentials alongside it, authorization lived only in the frontend React component, and no rate limit stopped the attacker enumerating every account in minutes. Your app does not need one catastrophic bug to be in trouble — four ordinary ones nobody checked together will do it. A scanner reporting "no criticals" can still be describing an app that hands over its user table, which is exactly what the Lovable build did, with zero Critical findings and 811 profiles readable anyway.

This is not a lab-only problem

The Astra study tested four demo builds. A separate scan of real apps found the same class of flaw at scale. In November 2026, Hamburg security firm Crissy Field analysed 159,041 Lovable projects found in the public Common Crawl archive (apps created December 2025 to September 2026). Of the 34,545 that used Supabase, 24,664 sent database records as soon as the page loaded, with no login. On 7,403 of those sites, further read-only requests returned tables containing email addresses — 10,560 tables in total. The worst cases are the kind of thing that ends a small business: a lifestyle forum with more than 80,000 profiles and over 200,000 private chat messages readable without a login, and a service provider with more than 1,000 passport records.

Two caveats from the researchers: the 30% figure is not a confirmed leak rate — some email addresses are public contact addresses or test data — and they could not establish whether any data was misused. The exposure itself is confirmed: read-only requests, no login, no hacking tool.

A July 2026 study from Xint, the autonomous pentest platform from Theori, points the same way. It found 434 exploitable issues across vibe-coded apps: resource exhaustion and denial-of-service flaws were the largest category at 93, broken authorization second at 88, and access-boundary flaws third at 54. Secrets exposure was the top source of critical-severity flaws, with 23 critical findings, 11 of them hardcoded or default secrets — the same failure mode as the leaked GitHub secrets that attackers' AI agents recently turned into live cloud access in five minutes. Notably, Xint found fewer injection bugs than expected — the models have improved there. The holes that remain are the ones a model cannot reason about from a prompt: who is allowed to see this record, how many requests this endpoint should accept, where that API key ended up.

The 10-minute check to run on your app tonight

Astra ships a universal 10-minute, browser-only checklist with the study, and it is the most useful thing in it for a founder without a security background. Run it on your live app, not the demo:

  1. Log in eight times with the wrong password and expect a 429 response around attempt six. If you can keep guessing, there is no rate limit on your login.
  2. Open DevTools and look for a Content-Security-Policy header on any response. Its absence is one of the cheapest findings in the study to fix.
  3. Reset a password with a fake email and then a real one, and confirm the response, wording and timing match. If they differ, your app confirms which accounts exist.
  4. Test your database like a stranger would. Open your production URL in a private window, or query a table with only your project's public anon key and no user session. If rows that should be private come back, your row-level security is off or a policy is wrong. In Supabase, open Advisors, then Security Advisor, and look for the rls_disabled_in_public finding.

That last check matters most for Lovable and Supabase apps. The public anon key is meant to be public — it ships in the frontend of every app. The only thing standing between that key and your data is row-level security: rules that say each user can only see their own rows. When RLS is off, Supabase hands every row to anyone holding the key. Lovable's head of security has said the root cause in the exposed apps was insufficient RLS — but a scan that checks whether RLS is switched on is not the same as RLS switched on correctly. A table can have RLS enabled with a policy that effectively allows everyone and still pass. And the service-role key, which bypasses RLS entirely, belongs on your server and nowhere else — if it is in your browser bundle, your database is wide open regardless of RLS.

What the prompt can and cannot fix

Astra's hardened prompt is worth using: it replaces adjectives with numeric thresholds — a maximum of 5 failed logins per account per 15 minutes with a 429 after, rather than "a secure login" — and names exact policies for rate limiting, enumeration prevention, CSP, cookie flags, JWT revocation, row-level authorization and audit logging. A more specific prompt is a direct fix for the 66 findings in the five universal classes.

But a prompt is layer one of three, and the study's own frame says so. Vibe-coding security sits at the prompt specification, the generated implementation, and post-generation verification — and a failure at any one layer produces exploitable findings regardless of which platform generated the code. The same pattern holds for v0 builds: the prompt gets you a working app, and the production failures arrive in a predictable order. The 13 Critical findings clustered in one app's auth implementation are not prompt problems. Neither is a Supabase policy that allows every row, or a service key shipped to the browser. Those are found by testing the running app, which is why the study's third layer — verification — is the one most founders skip entirely.

What we'd do

If this were our app at Lynxwell Digital, here is the order we would work in. First, run the 10-minute check above tonight — before the next user signs up, not after. Second, fix RLS in the database, not in the UI: enable row-level security on every table and add owner-scoped policies, then re-test with two accounts to confirm each one sees only its own rows. Third, treat the prompt as a spec going forward — paste Astra's hardened prompt as the first message on any new build, with the numeric thresholds in it. And fourth, before real users and real data arrive, get the running app tested by someone whose job is to break it. A demo that works is not a product that is safe, and the gap between the two is exactly what these studies keep measuring.

That last step is what our AI engineering team does for founders who built with Lovable, v0 or Bolt and now need the app to survive real users. Our Launch Safety Audit is $390, free if nothing critical turns up, and it covers exactly this ground — the running app, the database rules, the keys, the auth flows. If the app is already live and the check above turned up something you do not know how to close, send us the URL through our rescue page and we will tell you what is actually exposed before we talk about fixing it.

FAQ

Is my Lovable app secure?

Not by default. Astra's pentest of a Lovable-built app found 27 confirmed exploitable vulnerabilities, and a November 2026 scan of real Lovable apps found thousands with database records readable without a login. The risk is in the generated app and its database rules, not in Lovable's own platform. Run the 10-minute check in this post before you assume it is fine.

What is row-level security, and why does it matter for my app?

Row-level security (RLS) is a set of rules in your database that says which user can see which rows. Lovable apps usually store data in Supabase, and the app talks to Supabase from the browser with a public anon key that is meant to be visible. RLS is the only thing stopping that public key from returning every row to anyone. When RLS is off or a policy is wrong, anyone with your app's URL can read other users' data with no login.

Can I trust a pentest study from a company that sells pentesting?

Take the method, not the marketing. Astra sells the pentest service its study recommends, and it was named best autonomous pentesting tool of 2026 by CIO Times on November 13, 2026 — a commercial interest we have stated plainly. The findings are worth acting on because of the evidence bar: every finding was re-exploited by a validator agent and reviewed by a human engineer. And the Crissy Field scan, from a different firm, found the same class of flaw at scale.

Do I need a security expert to check my AI-built app?

You need someone to test the running app, not just read the code. The most severe findings live in the implementation layer, where a prompt cannot reach. The 10-minute browser check in this post catches the cheapest flaws yourself. For the rest — auth flows, database rules, exposed keys — a proper test of the running app is what finds them, and it is cheaper than finding out from a user.

What should I fix first on an AI-built app?

In this order: row-level security on every database table, rate limiting on login, and any secret or service-role key that ended up in frontend code. Those three close the flaws that show up in every study. Then fix the CORS configuration and the session handling, and only then worry about the long tail of mediums. If the 10-minute check turns up any of the first three, stop adding features until they are closed.

#vibe coding#AI app security#Lovable#app security
All posts

Shipped fast, broke in production?

That is the job we do most. Send the repo and a senior engineer records a 20-minute teardown: what is broken, how bad it is, and what it would cost to fix. Free, and the findings are yours either way.

First call's free
5.0 · usually replies in ~2 hours
  • Real human replies in ~2 hours
  • Fixed price, agreed before you pay
  • No lock-in, you own everything
  • Free first call + honest audit