A vibe-coded app is usually insecure in the same few places: database tables that anyone can read or write, secret keys bundled into the browser, permission checks that only exist in the user interface, and dependencies that nobody chose on purpose. Before you launch, check those four areas first, then any feature that calls an LLM, then error handling and abuse limits. This checklist is built from the OWASP Top 10:2025, the OWASP Top 10 for LLM Applications 2025 and the Supabase, Firebase, Next.js and GitHub documentation, all read on November 16, 2026.
"Vibe coding" here means building an app mainly by prompting an AI coding tool and accepting what it produces, often without reading every line. The tools are not the problem. The problem is that a prototype prompt asks for features, and security controls are rarely features anyone can see in a demo.
Why vibe-coded apps fail in the same places
The OWASP Top 10:2025 puts broken access control first, security misconfiguration second and software supply chain failures third. Those three map closely onto what a fast, prompt-driven build leaves behind. A demo works when the only user is you, so missing access rules do not show up. A default setting that made development easy stays in place. And a coding agent can add packages faster than anyone reviews them.
That is our reading of where the risk concentrates, not an OWASP statement about AI-built apps. The practical point is that you cannot rely on the code having been reviewed, so the checks below are written as things to test in the running app.
1. Database access rules
Many vibe-coded apps talk to a hosted database straight from the browser, typically Supabase or Firebase. In that design the database's own access rules are the security boundary, and nothing else stands in front of the data.
If you use Supabase
- Enable Row Level Security on every table in an exposed schema. Supabase's documentation says a table in an exposed schema without RLS is readable and writable by any role with a grant on it.
- Check the grants, not just the policies. On existing projects, a new table in
publicstarts with every privilege granted to theanon,authenticatedandservice_roleroles, and Supabase notes that adding policies does not take those grants back. Revoke what each role does not need. - Check your views. Views bypass RLS by default because Postgres creates them as security definer, so a view over a protected table can hand out the rows its policies withhold.
- Test the policies. Supabase recommends a test file per table that asserts allow and deny for select, insert, update and delete as both
anonandauthenticated, run withsupabase test db. Also test as a second signed-in user trying to read the first user's rows, because that is the bug a policy written by trial and error most often misses.
If you use Firebase
- Remove open rules. Firebase's "Avoid insecure rules" guide says a rule such as
allow read, write: if true;should never be used in production, because anyone who guesses your project ID can steal, modify or delete the data. - Leave test mode behind. Test mode grants access to all users. Firebase says to configure rules properly before you deploy, and to test changes with the local emulators.
- Check Cloud Storage as well as the database. Uploaded files have their own rules, and an open bucket exposes them just as an open database does.
2. Keys and secrets
- Know which keys may ship. Supabase documents its publishable key as safe to expose in web pages, apps and source code, because it only reaches what your grants and policies allow. Secret keys belong only in backend code. The legacy
service_rolekey bypasses RLS, so it must never reach the browser. Supabase says it is deprecating the legacyanonandservice_rolekeys by the end of 2026, and warns that a tool, tutorial or AI assistant telling you to copy a long key beginning witheyJwas written for the legacy keys. - Check what your framework inlines. In Next.js, any environment variable prefixed with
NEXT_PUBLIC_is inlined into the JavaScript sent to the browser at build time. A secret given that prefix to "make it work" is public. Other frameworks have similar prefixes, so check your own. - Search the built bundle, not just the source. Open the deployed site, view the JavaScript files and search for key prefixes and words such as
secretandsk_. This finds keys however they got there. - Keep
.envfiles out of git. Next.js notes thatcreate-next-appadds.envfiles to.gitignore. Check that your project still does, and check the repository history, since deleting a committed key from the latest version does not remove it from history. - Turn on push protection. GitHub's push protection for users is on by default and stops you pushing supported secrets to public repositories. Push protection for repositories is off by default, needs GitHub Secret Protection, and protects the specific repositories it is enabled on.
- Rotate anything that leaked. If a secret key was ever in the browser or in git, assume it is compromised and rotate it at the provider. Removing it from the code is not enough.
Coding agents also read secrets from your machine while they work. Our post on Claude Code settings.local.json and keeping secrets out covers that side.
3. Authorization on the server
- Check permissions on the server for every request. Hiding an admin button in the interface is not access control. Anyone can call your API routes or database directly with the browser's developer tools.
- Check ownership, not just sign-in. "Is this user signed in?" is a different question from "does this user own this record?". Change an ID in a request and see whether you get someone else's data.
- Keep payment and plan checks server-side. If the app decides in the browser whether a user has paid, a user can change that decision.
4. Dependencies an AI tool added
- Verify every package is real and intended. A 2024 study of 16 code-generating LLMs, analysing 576,000 code samples in Python and JavaScript, found that on average at least 5.2% of packages suggested by commercial models and 21.7% of those from open-source models did not exist. An attacker can publish malware under a name models tend to invent. Check the package name, publisher and download history before installing.
- Commit a lockfile and review changes to it. A lockfile pins exact versions, so a later install does not quietly pull something different.
- Remove what you do not use. Agents often add a package, try another approach and leave the first one installed.
5. LLM features inside the app
If the app itself calls an LLM, the OWASP Top 10 for LLM Applications 2025 applies on top of the web checks. The items that matter most for a small app are:
- Prompt injection (LLM01). Text from users, documents or web pages can carry instructions the model follows. Do not let model output decide on its own what data a user may see or what action runs. See what prompt injection is and how to defend against it.
- Sensitive information disclosure (LLM02) and system prompt leakage (LLM07). Assume users can get the model to repeat its instructions, and never put keys or private data in a system prompt.
- Excessive agency (LLM06). If the model can call tools, give it the narrowest set that works and require confirmation for anything that writes, sends or spends.
- Unbounded consumption (LLM10). Put rate limits and spending caps on any endpoint that calls a paid model, or one script can run up your bill.
6. Errors, logs and abuse limits
- Do not show raw errors to users. OWASP's 2025 list adds mishandling of exceptional conditions (A10). Stack traces and database errors in the browser tell an attacker how the app is built.
- Log security events. Failed sign-ins, denied requests and admin actions should be logged somewhere you will actually look (OWASP A09).
- Rate-limit sign-in, sign-up, password reset and any expensive endpoint.
Using an AI coding agent to help check
You can ask your coding agent to go through this list against the codebase, and it will find real problems. Two cautions. First, the same agent that wrote the code may share its blind spots, so treat its review as a first pass, not a sign-off. Second, several checks above can only be confirmed against the running app: trying another user's ID, calling a table as a signed-out user, or searching the deployed bundle. Some vendors now publish agent instructions for their own security setup; Firebase's rules guide, for example, includes a prompt for AI coding agents.
What this checklist does not cover
This is a pre-launch baseline, not a full security review. It does not replace a penetration test, a threat model for sensitive data, or compliance work such as GDPR or HIPAA obligations. If the app handles payments, health data or other people's personal data at any scale, have someone review it who did not build it. If agents run with access to your machine or production systems, also see our posts on sandboxing AI agents and the AI agent security checklist.
How we approach this
When a team brings us a prototype built with AI tools, we start from the data layer and the keys, because that is where a single mistake exposes everything. Then we add server-side authorization, tests for the access rules, and limits on anything that costs money per call, before the app is opened to real users. That review is part of our web and SaaS development and AI governance and security work, and it is often the step that decides whether a prototype is ready for production; our post on why AI prototypes fail in production covers the rest of that gap.
Sources: OWASP Top 10:2025, OWASP Top 10 for LLM Applications 2025, Supabase, Row Level Security (updated November 3, 2026), Supabase, API keys, Firebase, Avoid insecure rules, Next.js, environment variables, GitHub, push protection, Spracklen et al., "We Have a Package for You!" (arXiv 2406.10279). All read on November 16, 2026.