Check your own app — free, in about a minute.
The free mini-scan checks your live homepage for TLS/HTTPS basics, response security headers, cookie flags, exposed sensitive files, Firebase/Supabase backend rules, and the WordPress plugin versions your site exposes. You get a score and the finding titles — no account, no card.
Run the free mini-scan →You built your app with AI. It works. You're about to ship. This is the fastest meaningful security check you can run before you do — ten minutes, a terminal, and curl. No security background required.
This pass won't make your app bulletproof. It will catch the exposures behind the overwhelming majority of real-world incidents in AI-generated apps: leaked secrets, unprotected endpoints, open databases, and missing basics.
You need your app's public URL and a terminal. That's it. Run everything below against the deployed URL, not localhost — you want to see what the internet sees.
APP="https://your-app.com"
Replace with your actual URL for the rest of this guide.
AI builders constantly ship API keys inside client-side bundles. Your browser downloads your entire frontend — including anything the AI embedded in it:
# Find the JS bundles
curl -s $APP | grep -o 'src="[^"]*\.js"' | head -5
Download the largest bundle and search for key patterns:
curl -s $APP/assets/index-abc123.js | grep -oiE \
'sk_live_[a-z0-9]+|sk-test[a-z0-9_-]+|AIza[a-z0-9_-]{35}|AKIA[0-9A-Z]{16}|xox[bap]-[a-zA-Z0-9-]+|ghp_[a-zA-Z0-9]+' \
| sort -u | head
(Replace index-abc123.js with your actual bundle path from the first command.)
What you're looking for: anything starting with sk_live, AIza, AKIA, xoxb, or ghp_. Those are live credentials for Stripe, Google, AWS, Slack, and GitHub. If one appears, it's been public since deploy — rotate it immediately, then move it server-side so it never ships in a bundle again.
Also grep for the generic words — sometimes keys don't match a clean pattern:
curl -s $APP/assets/index-abc123.js | grep -oiE '"(api_key|secret|private_key)"\s*:\s*"[^"]{8,}"' | head
Open an incognito window, log out of your app, then hit the endpoints it uses — find them in DevTools → Network tab. From your terminal, which has no session at all:
for path in /api/users /api/orders /api/data /api/admin /api/stats /api/me; do
code=$(curl -s -o /tmp/resp.txt -w "%{http_code}" "$APP$path")
size=$(wc -c < /tmp/resp.txt)
echo "$path -> HTTP $code ($size bytes)"
done
What you're looking for: any 200 response with real data while you're completely unauthenticated. A 401 or 403 is correct. A 200 with a JSON array of users is a wide-open endpoint.
Don't stop at GET. If your app creates, updates, or deletes things, test writes too — against a test record, not real data:
curl -s -X POST $APP/api/notes \
-H "Content-Type: application/json" \
-d '{"title":"security probe","body":"delete me"}' \
-o /dev/null -w "POST /api/notes -> %{http_code}\n"
A 201 or 200 here with no login means anyone on the internet can write to your database.
AI builders leave scaffolding behind — /debug, /test, /admin, database viewers, seed endpoints. Sweep for them:
for path in /debug /test /admin /api/debug /api/test /seed /reset /console /_debug; do
code=$(curl -s -o /dev/null -w "%{http_code}" "$APP$path")
echo "$path -> $code"
done
What you're looking for: 200s on paths you don't recognize. Anything the AI built "for testing" that you never removed is now a public feature of your app. Delete debug routes, or put real authentication in front of admin tooling — an unlinked URL is not access control.
One command, instant signal about your baseline:
curl -sI $APP | grep -iE 'content-security-policy|x-content-type-options|x-frame-options|strict-transport-security|referrer-policy'
What you're looking for: if none of these appear, your app is missing one-line defenses against clickjacking, MIME-sniffing attacks, and protocol downgrades. Add them at your hosting layer or framework config — this is the highest ROI minute of the ten.
Error messages are where apps accidentally confess. Force a few failures and read the responses. In production, errors should say "something went wrong" and nothing else — details go to your server logs, not the response body:
# Bad ID — does the error reveal internals?
curl -s $APP/api/users/this-is-not-a-real-id | head -c 600
echo
# Malformed JSON — stack trace?
curl -s -X POST $APP/api/data \
-H "Content-Type: application/json" \
-d '{"broken": json}' | head -c 600
echo
# Nonexistent deep path — framework fingerprint?
curl -s -o /dev/null -w "%{http_code}\n" $APP/api/../../../etc/passwd
What you're looking for: stack traces, SQL fragments, file paths, database connection strings, framework version banners.
AI-generated apps almost never ship with rate limiting. Verify with 30 rapid-fire bad logins:
for i in $(seq 1 30); do
curl -s -o /dev/null -w "%{http_code} " -X POST $APP/api/login \
-H "Content-Type: application/json" \
-d '{"email":"nobody@example.com","password":"wrongpassword"}'
done
echo
What you're looking for: thirty 200s or 401s in a row with no 429 means an attacker can brute-force your login at full speed, forever. Add rate limiting (your framework has a middleware for this — express-rate-limit, slowapi, Next.js middleware counters, or your host's edge rules).
Keys in git history stay compromised even after you delete the file. If a key appears anywhere in history, rotating it is mandatory — removing it from current files is not enough:
git log -p --all -S 'sk_live' -- . | head -20
git log -p --all -S 'AKIA' -- . | head -20
And scan current files for the obvious:
grep -riE 'sk_live|api_key\s*=\s*["\x27][^"\x27]{8,}|password\s*=\s*["\x27][^"\x27]{4,}' \
--include='*.js' --include='*.ts' --include='*.py' --include='*.env*' . 2>/dev/null \
| grep -v node_modules | grep -v '.git/' | head
What you're looking for: anything that was ever committed — history doesn't forget.
| Check | Pass looks like |
|---|---|
| Bundle secrets | No key patterns in client JS |
| API auth | 401/403 on every data route when logged out |
| Debug routes | 404 on all scaffolding paths |
| Headers | CSP, nosniff, HSTS all present |
| Error handling | Generic messages, no stack traces or SQL |
| Rate limiting | 429s after rapid bad logins |
| Git history | No secrets ever committed |
Every row that fails is a fix to make before launch, ordered roughly by how quickly an attacker would exploit it. Leaked live keys and open write endpoints are drop-everything-and-fix-now.
Vibe-coded apps evolve fast, and AI refactors are exactly how an auth check quietly disappears or a key ends up back in the bundle. Make this 10-minute pass part of your deploy ritual, not a one-time event.
Ten minutes is cheap — but easy to skip. PreShipIt does the attacker-style probing for you: paste your app's URL, attest that you own it, and get a plain-English prioritized report of what's reachable and exposed, before strangers find it.
Don't want to do it by hand? PreShipIt scans your app from the outside for $29, one time.
Note on scope: PreShipIt runs an outside-in, unauthenticated scan of the single host you submit. It doesn't test anything behind a login, doesn't review your source code, and doesn't guarantee your app is secure — it shows you what an unauthenticated visitor can see and reach, so you can fix it first.
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.
The free mini-scan checks your live homepage for TLS/HTTPS basics, response security headers, cookie flags, exposed sensitive files, Firebase/Supabase backend rules, and the WordPress plugin versions your site exposes. 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