Check your own app — free, in about a minute.
Most of the mistakes on this list are visible from outside the app — missing headers, an exposed .env or .git, open database rules, keys in client code. The mini-scan checks your live app for exactly those. You get a score and the finding titles — no account, no card.
Run the free mini-scan →AI coding tools are remarkably consistent — including in the security mistakes they make. Generate ten apps with ten different tools and you'll find the same holes in most of them. That's actually good news: once you know the pattern, you can check for all of them in an afternoon.
Here are the seven that show up again and again, with concrete ways to find and fix each one.
The most common and most damaging mistake. The AI needs an API key to make something work, so it drops it into the frontend code where it "just works" — and where anyone can read it.
How to check: Search your built and source JavaScript for key patterns:
grep -rhoE "(sk_live_[A-Za-z0-9]+|AKIA[A-Z0-9]{16}|ghp_[A-Za-z0-9]{36}|xox[bap]-)" dist/ build/ .next/ 2>/dev/null
grep -ri "api_key\|apikey\|secret" src/ --include="*.ts" --include="*.tsx" --include="*.js" | grep -v "process.env"
Also open your app, hit F12, go to Sources, and search the bundled JS for supabase.co, firebase, or api_key. Anything sensitive you find there is public.
Fix: Move every secret server-side. The frontend gets a public key (like a publishable key) or nothing at all; privileged calls go through your backend, which holds the real secret in environment variables. If a key was ever in client code or a commit, rotate it — you can't un-publish it.
The AI hides the admin page behind a login screen and calls it done. But hiding a route in React Router is not access control — the API underneath still answers anyone who asks.
How to check: Log out, then request the protected data directly:
# Try the API behind a "protected" page with no credentials
curl -s "https://yourapp.com/api/admin/users" | head -c 500
curl -s "https://yourapp.com/api/invoices/12345" | head -c 500
If you get data instead of a 401, your "protected" page is decoration.
Fix: Every API endpoint and server function must verify the caller's identity and authorization independently of what the UI shows. The frontend is a convenience; the backend is the lock.
Ask the AI for a login form and it builds the form. It doesn't build the part that stops someone from trying 10,000 passwords against it. Registration, login, password reset, contact forms, public APIs — AI-generated apps almost never throttle any of them.
How to check: Hammer your own endpoints and see what happens:
for i in {1..50}; do
curl -s -o /dev/null -w "%{http_code}\n" -X POST https://yourapp.com/api/login \
-H "Content-Type: application/json" \
-d '{"email":"test@test.com","password":"wrong"}'
done | sort | uniq -c
If all 50 come back 200/401 with no 429s, you have no rate limiting.
Fix: Add throttling at the edge (Cloudflare, your hosting provider's WAF) or in the app (libraries like express-rate-limit, or your framework's equivalent). Login and password reset are the priority targets.
AI-generated error handling loves detail: full stack traces, database error messages, ORM query dumps. Each one hands an attacker a map of your tables, your query structure, and your framework version.
How to check: Trigger errors on purpose — bad input, malformed JSON, a nonexistent record ID — and read the responses:
curl -s "https://yourapp.com/api/users/abc" # non-numeric ID
curl -s -X POST https://yourapp.com/api/search \
-H "Content-Type: application/json" -d '{broken json'
Look for table names, SQL fragments, file paths, or stack traces in the output.
Fix: Return generic errors to users ("Something went wrong"), log the detail server-side. And make auth errors uniform: "Invalid email or password" for both wrong-email and wrong-password — never "user not found," which tells attackers which accounts exist.
*When the frontend and API live on different origins during development, the AI "fixes" the CORS errors the fastest way it knows: Access-Control-Allow-Origin: *. That header then ships to production, letting any website on the internet make credentialed requests to your API from a victim's browser.
How to check:
curl -s -I -H "Origin: https://evil.example" https://yourapp.com/api/data \
| grep -i "access-control-allow-origin"
If it echoes back * or the attacker's origin, it's too permissive.
Fix: Restrict CORS to your own domains. If it's genuinely a public API with no credentials involved, * is acceptable — but that's a deliberate decision, not a leftover.
Parameterized queries are a solved problem, but AI-generated code still occasionally builds SQL by string concatenation — especially in search filters, sort parameters, and admin tools where the query gets "clever." One unsanitized sort parameter is all it takes.
How to check: Search your codebase for query-building patterns:
grep -rn "query.*+\|execute.*+\|raw(" src/ --include="*.ts" --include="*.js" --include="*.py" | grep -vi "test"
Then test search and filter endpoints with a classic probe like ' OR '1'='1 and watch for database-flavored errors or suspiciously complete result sets.
Fix: Use parameterized queries or your ORM's query builder everywhere — no exceptions for "internal" tools. Escape output too: anywhere user content is rendered, verify <img src=x onerror=alert(1)> doesn't execute.
The AI picks libraries to get the job done. It doesn't check whether the version it pinned has a known critical CVE, and it won't tell you when a new one drops. AI-built projects routinely ship with months-old dependencies carrying public exploits.
How to check: Run your ecosystem's audit tool and read the output honestly:
npm audit # or: pip audit, bundle audit, cargo audit
Fix: Fix criticals before launch, then set up Dependabot or Renovate so it doesn't rot. This one is pure hygiene — five minutes now saves an incident later.
Notice what these seven have in common: none of them are about the AI writing "bad code." The code works. The mistakes are all things the AI didn't write — the auth check it skipped, the rate limiter it never added, the error message it left verbose. Vibe coding optimizes for the demo; security lives in everything around the demo.
So the real checklist item is a mindset shift: test like an attacker, not like a user. Users click the happy path. Attackers try the logged-out curl request, the swapped ID, the fifty-first login attempt. Run each check above before launch, and re-run them after every big AI-assisted change — a refactor that "just cleaned things up" can quietly drop an auth check.
Working through all seven takes real time — and the one you skip is the one that matters. PreShipIt does the attacker-style probing for you from the outside for $29, one time: paste your app's URL, confirm you own it, and get a plain-English prioritized report of what's exposed. It doesn't log in, review your code, or guarantee security — it shows you what a stranger can see before they see it.
Get your pre-ship inspection at preshipit.com
The PreShipIt Brief — a short weekly email for people shipping vibe-coded apps: the week's important vulnerabilities and launch-safety checks, in plain English.
New and free. Double opt-in: we email you a confirmation link before anything else arrives. Unsubscribe any time.
Check your own app — free, in about a minute.
Most of the mistakes on this list are visible from outside the app — missing headers, an exposed .env or .git, open database rules, keys in client code. The mini-scan checks your live app for exactly those. You get a score and the finding titles — no account, no card.
Run the free mini-scan →← Back home · Run a free mini-scan · Scan my app — $29 · See a sample report