Vibe Coding Security: 10 Checks Before You Ship an AI-Built App

Key Takeaway

• 🛡️ The stakes: The Verge reported on June 22, 2026 that Red Access researchers found about 5,000 publicly accessible apps built with AI coding tools that have no login at all, and close to 2,000 of them appeared to be leaking sensitive data.
• 📦 What leaks first: API keys, database credentials, and private messages. The Moltbook incident in late January exposed tens of thousands of email addresses and private chats from an app whose founder wrote no code himself.
• 🔍 The check: Vibe coding security is a 10-point pre-ship list. Every check below runs in minutes with a single command or a pasted prompt.
• ⚙️ The failure pattern: Veracode tested more than 100 AI models and found 45% of AI-generated code samples contained a flaw that could expose data. The same few insecure defaults repeat at scale.
• 🚦 Tonight: Run the 10 checks below on any AI-built app before it faces a real URL, then again after every AI-written patch.

Matt Schlicht launched Moltbook in late January 2026, a social network built entirely by AI coding tools, and he never wrote a line of its code himself. Within days, researchers at the security firm Wiz found the app’s entire production database sitting wide open on the internet, exposing tens of thousands of email addresses and private messages. He had shipped a system that worked perfectly in the demo and failed exactly where it counted.

He is not an outlier. The Verge’s June 22, 2026 security report on vibe-coded apps collects case after case: a project manager who discovered a hidden SQL injection flaw in his tax-tracking site months after launch, a founder whose AI agent wiped his company’s production database, and a serial entrepreneur who took his demo app offline after attackers found it. Vibe coding security is the plain name for the gap between “the app works” and “the app is safe to give a real URL.” This guide hands you the 10 checks that close that gap tonight, each with the exact command or prompt to run.

What Vibe Coding Security Actually Means

Vibe coding means building software by describing what you want in plain language and letting an AI tool write the code. Tools like Cursor, Lovable, Bolt, v0, and Claude Code produce working apps in hours. The problem is not intelligence. The problem is what the model optimizes for.

AI models optimize for code that runs, not code that resists attack, and that single bias is why vibe coding security needs to be its own step. Security researchers at Veracode tested the security quality of AI-generated code across more than 100 models and found that 45% of the samples they tested contained a security flaw, and no major language was immune. The March 2026 benchmark repeated the same 45% failure rate when prompts gave the model no security guidance. The code compiles, the demo works, and the vulnerability hides in a default the AI never questioned. This is the gap vibe coding security exists to close.

Three structural reasons explain why this keeps happening:

The prompt is the spec, and the spec is incomplete. When you ask for “add a profile page” you never say “and only the owner may read it.” The AI fills the gap with the default it has seen most often, which is no permission check at all. A page that loads one profile looks identical to a page that loads every profile.

Working features hide broken limits. With a single account you cannot see the difference between an app that protects data and an app that does not. The bug is invisible to the founder until a stranger arrives.

The model reuses its own mistakes. Once an insecure pattern lands in your files, the AI sees it on the next turn and treats it as the house style. One bad endpoint becomes ten by the end of the session. Security researchers call this class of failure copy-paste propagation, and it is why the first files an AI writes deserve extra attention.

None of this makes AI-built software hopeless, and none of it is hard: vibe coding security succeeds with commands a single afternoon can run. Every bug class on this page, from SQL injection to leaked secrets, has sat on the OWASP Top 10 for a decade, and mature teams catch them with review. Vibe coding security is simply that review, written out in plain steps. It matters whether you build with Cursor all day or, like thousands of freelancers who followed our Vibe Coding OFW guide, deliver client work in an afternoon.

The 10-Check Pre-Ship List

Vibe coding security starts the same day you deploy, not the day after an incident. Run these ten checks on anything AI-built. Paste the commands into your project folder or your AI coding tool. Ten minutes here beats a breach report later.

1. Run the secrets sweep

Hardcoded keys are the most common leak in AI-built apps, because the model happily pastes credentials into config files to make things work. Search the whole project, then search your git history, because deleting a file does not remove what earlier commits already recorded:

grep -rn --include="*.*" -E "(sk_live|sk-[A-Za-z0-9]{20,}|api[_-]?key|secret|password)\s*[:=]" . | grep -v node_modules
git log -p | grep -E "sk_live|sk-[A-Za-z0-9]{20,}"

If anything real appears, rotate the key at the provider first, then remove it from the code. Move the replacement into environment variables or the platform’s secret store. Open-source scanners such as git-secrets or gitleaks automate this sweep on every commit. One habit closes the whole class: never paste a real production key into an AI chat to “fix” something, because the prompt becomes part of your chat history.

2. Put the database behind a permission layer

Most AI app builders generate code for hosted databases like Supabase or Firebase, and they often leave every table readable by the public placeholder key. Enable Row Level Security (RLS) so the database itself refuses rows a signed-in user does not own. In Supabase, for every table with user data:

alter table public.orders enable row level security;
create policy "own rows only" on public.orders
  for select using (auth.uid() = user_id);

Then check the keys your frontend actually ships. The public “anon” key is safe in a browser only when RLS protects every table. The service_role key bypasses all rules and must live on a server, never in client code. In vibe coding security this one setting is the wall: it separates the thousands of safe apps from the thousands of open ones.

3. Attack every protected route yourself

Vibe coding security tests every route as an attacker would, because AI builders love adding login screens in the frontend while leaving the backend route open. The page hides; the API does not. Test it with curl, with no cookie and no token, against every route that reads or writes user data:

curl -i https://[your-app]/api/orders
curl -i -X POST https://[your-app]/api/orders -d "{}"

Anything that returns data or a success status instead of 401 or 403 is a finding. Fix it by moving the check into the route handler itself, one route at a time, with no exceptions.

4. Prove the packages really exist

AI sometimes invents library names, and attackers have learned to publish malicious packages under the names models hallucinate most often, a supply-chain trick researchers call slopsquatting. Every import in your project must resolve to a real package in the official registry:

npm audit
pip-audit
npm ls --depth=0

Check each dependency name you do not personally recognize against the npm or PyPI registry page. Anything missing from the registry is either a hallucination or an attack, and either way it comes out of your project today.

5. Empty every silent catch

AI-generated error handling often swallows failures. A permission check that throws inside a catch (e) {} block becomes a successful response, which is the worst possible failure mode, because the attacker sees success and you see nothing:

grep -rn --include="*.js" --include="*.ts" -E "catch\s*\((e|err|error)?\s*\)\s*\{\s*\}" .

Every caught error must at minimum log the failure and, for security-relevant paths, return a failed status. If the app answers a failed permission check with 200 OK, fix it before anything else on this list.

6. Sanitize what the AI puts in your HTML and SQL

The two classic injection bugs still arrive in AI code. SQL built by gluing strings together lets a stranger read or change your database; raw HTML rendering lets a stranger run scripts in your users’ browsers. AI writes both patterns because they appear in its training data. Require parameterized queries for every database call, and refuse to render model output as raw HTML. In a React app, dangerouslySetInnerHTML deserves a search and, usually, a removal:

grep -rn --include="*.tsx" --include="*.jsx" "dangerouslySetInnerHTML" .
grep -rn --include="*.py" --include="*.js" -F "execute" .

7. Close the debug doors

Development leftovers ship surprisingly often in AI-built apps because the model copies the dev configuration into production. Before launch, confirm: verbose error pages that print stack traces are off; debug endpoints like /debug or /admin with no password are closed; the database admin panels (phpMyAdmin, Supabase dashboard) are not publicly reachable; and demo accounts are deleted. Test from a fresh browser session where you are logged in to nothing.

8. Rate-limit anything that costs money or sends messages

If your app calls a paid AI API, sends email, or triggers webhooks, an open endpoint becomes an open wallet. Add rate limits on the server for every endpoint that costs you something, and require a valid session before the app spends a cent. A simple test: hold down the submit button for thirty seconds and watch your billing dashboard. AI agents hammer free endpoints politely and at scale, which is exactly how a hobby project produces a surprise invoice.

9. Make the AI produce a threat model you can read

Vibe coding security review works better when the reviewer knows what matters. Your AI coding agent is the reviewer you already have. Give it the context and demand evidence, using the prompts in the section below. A generic “is this code secure?” produces a generic yes. A prompt that names your data, your users, and your external services produces findings you can act on.

10. Re-check after every AI-written patch

The checks above are not one-time. Every new feature the AI writes, including the security fix the AI writes for you, can introduce the same defaults all over again. Run the secrets sweep and the route test after every meaningful change, and keep the open-source vibe-check security checklist repository in your project so the rules stay visible to the AI itself. Teams that review only once ship the bug that arrived last.

The Cases Behind the Numbers

The failures above are not theoretical. Four cases reported by The Verge in June 2026 show how each check closes a real wound:

Read together, the table says one thing plainly: the same handful of defaults fails the same way at every scale, from a family toy to a viral network. Vibe coding security exists because the AI will not ask those four questions for you.

The professionals quoted by The Verge put the boundary in human terms. Gabriel Bernadett-Shapiro, an AI research scientist at SentinelOne, said “vibe coding is not bad because amateurs can build software. That’s actually the good part.” The danger, in his words, arrives when a personal app drifts into business software that stores other people’s data. “The moment that it touches other people’s personal data, then that’s when I think the standard changes.” Jack Cable, CEO and cofounder of Corridor, said vibe coding “is great for lower risk things,” while financial records and anything on the public internet deserve more scrutiny.

Prompts That Make the AI Do Part of the Work

Your AI tool built the problem, so put it on the fix; prompt discipline carries the review half of vibe coding security. Paste these two prompts into the same session that wrote the app. Both follow a rule that matters: name your specifics in the bracketed slots, because generic prompts produce generic warnings.

Prompt 1, the threat model:

Create a threat model for this app before reviewing any code.
The app stores: [user accounts, orders, chat logs, uploads...]
Users can: [sign up, buy, upload...]
Sensitive operations that must stay private: [name them]
External services it calls: [payments, email, AI API...]
Where it runs: [local, vercel, supabase, vps...]
List the highest-risk data flows, the auth boundaries, and realistic
abuse cases. Then score each risk: critical, high, or low. Do not
write code yet.

Prompt 2, the evidence-checked review:

Now review the code against that threat model. For every risk you
named, either show me the file and line that handles it correctly,
or show me the file and line that fails it. Quote the code. Verify
claims by reading the file, not from memory. End with the three
smallest fixes that close the largest risks.

The second prompt matters more than the first. AI tools state that code “looks secure” far too easily, and the belief gap is the real risk. Asking the model to quote the file and line turns a feeling into evidence. When the model cannot produce the quote, you have your first finding. Evidence-quoted review is the part of vibe coding security that turns a chatbot from a yes-machine into a working auditor.

When a Fun Project Becomes Business Software

There is a moment every vibe coder should learn to recognize, and it is not a moment you will feel. Nothing rings. The app simply crosses a line: it starts storing data that belongs to someone else. A workout tracker for yourself has a low security bar. The moment it holds customer records, medical notes, financial details, or your employer’s documents, it carries obligations no matter how small it looks, and the SentinelOne research quoted above says the standard changes at exactly that line. It is the moment where vibe coding security stops being optional.

For freelancers and small agencies, this is the line where client work lives. If you deliver an AI-built app to a paying client and hand them the database keys, your name rides on the security of that app forever. Running this vibe coding security list before delivery is the cheapest insurance available, and the real comparison is plain: a paid professional security review of a serious project runs to four or even five figures, while the ten checks above cost one evening. Use the checks for everything you ship, and use a professional review when the data is sensitive and the stakes are real.

Build volume makes this personal. AI coding tools have multiplied the number of apps produced, and as The Verge’s report concludes, that multiplies the number of security failures in equal proportion. Our related coverage follows the same shift from other angles: what the vibe coding boom means for coding careers, the hygiene checks worth running on AI agent memory, and the pre-deploy rules in our self-hosted AI security guide and our AI agent security checks.

Frequently Asked Questions About Vibe Coding Security

Is vibe coding safe for real apps?

Vibe coding security is exactly what makes it safe: the builder treats the AI output as a first draft nobody has reviewed yet. The Veracode study found 45% of AI-generated code samples contained a security flaw, so “the app works” proves nothing about security. Run the 10-check list above before any real users arrive, and again after every AI-written change.

What is the most common vulnerability in AI-built apps?

Missing authorization on server routes, followed closely by exposed secrets and open database permissions. The AI writes the frontend login screen but skips the backend check, and the founder never notices because the demo works. Test every protected route with curl and no session token, exactly as check 3 shows.

Does AI-generated code really have more vulnerabilities than human code?

Yes, by every published measurement so far. Veracode’s research across more than 100 models found 45% of AI-generated samples introduced a known security flaw, and industry trackers found AI-generated code carrying more vulnerabilities per unit than human-written code. The pattern matters more than the exact number: the same insecure defaults repeat across thousands of apps.

What is slopsquatting?

It is a supply-chain attack aimed specifically at AI coding. The model occasionally invents a library name that does not exist, and attackers publish a malicious package under that invented name, hoping a developer installs it. Prove every dependency exists in the official npm or PyPI registry, as check 4 shows, and treat any package you cannot find as an attack or a hallucination.

How do I check if my API keys already leaked?

Search the code and the git history with the commands in check 1: grep the project for key patterns, then search committed history with git log. Anything found in history counts as leaked even if the current file is clean, because old commits are public the moment the repo is. Rotate the key at the provider, then move the new one into environment variables.

Do I need Row Level Security if my app has a login?

Yes, if the login is only in the app. RLS enforces ownership inside the database itself, so a bug in your app’s code or a leaked public key cannot expose rows the database would refuse to serve. Enable it on every table that holds user data, then confirm the service_role key only lives on a server.

Do personal or internal tools ever need a full security review?

A local tool that touches only your own files has a low bar. The standard changes when the app is on the public internet, holds other people’s data, or connects to anything paid. For those cases, the 10 checks are the floor, and a paid review by a security engineer is the right step before the app holds anything you would be embarrassed to see in a breach report.

The pattern across every case here is stubbornly consistent. The app that breaks is the app that works, because working code ships and unreviewed defaults sit underneath it. Run the ten checks before your next deploy, paste the evidence prompt into the session that wrote your code, and you will close tonight the same doors that opened on 5,000 apps before yours.

@online{agron2026vibecoding,
  author       = {Agron, Edmon},
  title        = {{Vibe Coding Security: 10 Checks Before You Ship an AI-Built App}},
  year         = {2026},
  date         = {2026-11-10},
  organization = {WorldNgayon},
  url          = {https://worldngayon.com/vibe-coding-security/},
  urldate      = {}
}

TY  - ELEC
AU  - Agron, Edmon
TI  - Vibe Coding Security: 10 Checks Before You Ship an AI-Built App
T2  - WorldNgayon
PY  - 2026
DA  - 2026/11/10/
UR  - https://worldngayon.com/vibe-coding-security/
Y2  - 
ER  -