security checks for vibe-coded apps

Your app works.
Is it leaking?

VibeProtect checks the app you built with Lovable, Replit, Bolt, Cursor or appgnt, and the code behind it. It finds leaked keys and database rules that let anyone in, then hands you a prompt that fixes each one, written for your builder.

7-day free trial. No card, no install.

Example: VibeProtect reading the JavaScript that myapp.lovable.app sends to every visitor, and flagging an OpenAI key in it and the OpenAI SDK set to run in the browser.
works with apps built on

what we find

The holes AI builders leave, said in plain words.

AI builders are great at making things work. They are less careful about who else can use what they made. These are the common ones, and the ones we check for.

Your OpenAI key is in your JavaScript

Anything your app's code holds, every visitor downloads. A key in there is a key anyone can copy and spend.

live app: leaked API keys in the bundle

Your AI SDK runs in the browser

Builders sometimes flip a setting literally named dangerouslyAllowBrowser. It hands your AI key to every visitor.

live app: AI SDK called from the browser

Your Supabase master key is public

The service_role key ignores every access rule. In front-end code it means anyone can read, change or delete all of your data.

live app + repo: service_role key in browser code

Anyone can download your users table

Your Supabase key is public by design; Row Level Security is what stops it reading everything. We use that same key to ask each table for one row, so you know for sure, not maybe. We keep the column names, never the data.

live app: confirmed Supabase and Firebase reads

A table shipped without rules

We read your Supabase migrations and Firebase rules files and flag every table that never turned RLS on, and every rule that says "anyone".

repo: migrations without RLS, open Firebase rules

There is a password in your GitHub repo

Keys pasted into code, or a whole .env file, get synced to GitHub along with everything else. We find them and tell you which to rotate.

repo: committed secrets and .env files

A package you use has a known hole

Your app runs on hundreds of open source packages. We look up the exact versions you have and tell you what to bump.

repo: vulnerable dependencies (OSV.dev)

Anyone can call your server functions

An edge function that sends email, spends AI credits or returns other people's data without checking who is asking. Patterns miss these, so an AI reviews your code like a security engineer would.

repo: AI code review
Every check, explained →

Headers, HTTPS, forms and the rest, each in one plain sentence.

the fix is a prompt

You built it by prompting. You can fix it the same way.

Every finding comes with a prompt worded for the builder that made your app. Paste it in, let it make the change, rescan. No security course required.

highsecrets.openai-key

OpenAI API key exposed in your public JavaScript

Anyone who visits your app can read your OpenAI key in the JavaScript their browser downloads. Whoever copies it can use it on your bill.

key
sk-proj-Ab…9xQ
found in
/assets/index-4f2a9c1b.js
used by
new OpenAI({ dangerouslyAllowBrowser: true })

Step one is yours: revoke the key in your OpenAI dashboard and make a new one. Deleting it from the code does not un-leak it.

Paste into Lovable click to select

Security fix: my OpenAI API key is in the front-end code, so anyone visiting the site can copy it.
Move the OpenAI call into a Supabase Edge Function, store the new key as a Supabase secret named OPENAI_API_KEY, and have the front end call that function instead.
Remove the key from every front-end file and from any VITE_ environment variable. Do not change the UI.

then rescan to confirm it is gone

show your work

Proof your app is looked after, not a promise.

Customers, clients and investors increasingly ask "is it secure?" Send them something better than "I think so". Both links always show your latest scans, and you can turn either off at any time.

A badge for your footer

Links to a public trust page: ownership verified, rescanned daily or weekly, which checks ran, and whether anything serious is open. No findings, so it is safe to show anyone.

VibeProtect: monitored ✓VibeProtectmonitored ✓

A full report for a client

Every open finding, what it means and how it is being fixed, plus anything you deliberately set aside and why. Unlisted, and it prints to a clean PDF.

agencies: hand it over with the project

Checked, not claimed

The badge only turns green while ownership is verified, the last scan is under a week old and nothing critical or high is open. If that changes, so does the badge.

updates on its own

how it works

Four steps, mostly copy and paste.

  1. 01

    Paste your app's address

    The URL it is live at. We tell which builder made it from the address and the code.

    myapp.lovable.app
  2. 02

    Ask your builder to verify it

    We give you a prompt. Your builder adds a tiny file to prove the app is yours.

    /.well-known/vibeprotect.txt
  3. 03

    Scan

    You get a grade and a short list, worst first, in plain language.

    2 findings · grade D
  4. 04

    Paste the fix prompt

    Copy the prompt for each finding into your builder, then rescan to see it go green.

    > Paste into Lovable

the rule we do not bend

We only scan apps you prove you own.

A scanner that checks any URL you type is a tool for snooping on other people's apps. So before the first scan, you show us the app is yours, and we re-check that every night.

  • The exact address, nothing else. Verifying myapp.lovable.app covers that app, not anything else on lovable.app.
  • Read-only, always. No logins, no attack traffic, no writes. We read what any visitor's browser already gets.
  • Repos through GitHub only. We read code only from repos you installed our GitHub App on, and never run it.
  • We say who we are. Our scanner identifies itself as VibeProtect-Scanner/1.0 (+https://vibeprotect.dev/scanner).
A small fileany app

Your builder adds it to the public folder.

https://myapp.lovable.app/.well-known/vibeprotect.txt
A meta tagany app

One line in the head of your home page.

<meta name="vibeprotect-verification" content="vibeprotect-verify=...">
A DNS recordcustom domains

A TXT record, if you have your own domain.

_vibeprotect.app.example.com TXT "vibeprotect-verify=..."

a public service announcement

Don't become a LinkedIn post.

A leaked key is found in forty seconds by anyone who looks. What follows is two weeks of strangers with takes, none of whom have seen your app. The fix takes ten minutes, and nobody has to know.

Brayden K. Founder | Ex-Founder | Future Founder | 3x LinkedIn Top Voice Day 3
the flood begins

I've been saying this for YEARS.

Vibe coding is not engineering.

Agree? ♻ Repost so your network sees it.

2,418 reactions312 comments896 reposts

Parody. Nobody real. The pattern, unfortunately, is.

pricing

Free to find out. Cheap to keep watching.

Builder

$12/month
billed monthly

For your side projects: the live app and the code behind it, with a heads-up when a new prompt breaks something.

Pro

$29/month
billed monthly

For people shipping for real: daily rescans, and your AI agent can scan and fix on its own.

questions

Fair questions.

Is it safe to scan my app?

Yes. We read what any visitor could already read: your pages, the JavaScript they load, your headers and your HTTPS setup. We never try to log in, guess passwords, send attack traffic or write anything. And we only scan an app after you prove it is yours. The repo scan reads your code through our GitHub App and never runs it.

Do you store my data or my keys?

We never store secret values or any data from your database. When we find a key we keep a redacted version (like sk-proj-Ab…9xQ), enough for you to know which key to rotate and not enough to use it, plus the file and line where it was. To check whether your database is open, we ask it for one row using the public key your app already ships to every visitor, and keep only the column names and a count, never the values. Your repo is read for the scan and not kept afterwards. If you leave the AI code review on, the source goes to Google's Gemini API for that review and is not stored there.

How is this different from Lovable's built-in security scan?

Use both. Lovable's scans review your project from the inside, while you build. VibeProtect tests the published app from the outside, the way a stranger would: what is in the JavaScript you actually shipped, how the site is served, and whether your database really answers to someone who is not signed in. It also scans the GitHub repo Lovable syncs to, with an AI code review included, keeps rescanning on its own, and tells you when something changes. It works the same way for apps from Replit, Bolt, v0, Manus, Cursor or appgnt (where one click connects your account instead of a file).

How good is the AI code review?

It reads your code the way a security engineer would, server code and database rules first, and looks for what pattern checks cannot see: users who can read each other's data, server functions anyone can call, input that reaches a query or a prompt, sign-in and payment logic that can be skipped. Every finding names the file and line so you can check it, and ones that depend on settings it cannot see are marked as such. It runs when you start a repo scan (a few a month on every plan); your code goes to Google's Gemini API for the review and is not stored there.

Can I show customers that my app is checked?

Yes. Turn on a public trust page and put the badge in your footer: it shows you proved you own the app, how often we rescan it, which checks ran, and whether anything serious is open, never the details. For a client or an investor, share an unlisted full report instead, with every open finding and how it is being fixed. It prints to PDF.

Does it work if I don't use GitHub?

Yes. The live app scan only needs your app's address. It finds leaked keys in your JavaScript, AI SDKs running in the browser, Supabase tables and Firebase data that strangers can read, and problems with headers, HTTPS and forms. Connecting GitHub (on paid plans) adds the repo scan: committed secrets, vulnerable packages, Supabase migrations without RLS, Firebase rules files, risky code, and an AI review of the code itself.

I don't really know what RLS or an SDK is. Is that a problem?

Not at all. Every finding starts with what it means for you, and comes with a prompt you paste into the builder that made your app. It knows what RLS is, so you do not have to.

Why do I have to verify my app?

Because we will not scan an app for someone who does not own it. Verifying takes one prompt: we give you the exact words, your builder adds a small file or tag, and you are done. See how verification works.

Check your app before someone else does.

Seven days free, no card. The hardest part is asking your builder to add a file.