The 10-Minute Pre-Launch Security Pass for Vibe-Coded Apps

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 →

The 10-Minute Pre-Launch Security Pass for Vibe-Coded Apps

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.

Minute 0: Set Up

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.

Minutes 1–2: Hunt for Leaked Secrets in Your JavaScript

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

Minutes 3–4: Curl Your API Routes Logged Out

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.

Minutes 5–6: Check for Open Debug Routes and Admin Panels

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.

Minute 7: Check Your Security Headers

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.

Minute 8: Trigger Errors and Read What Leaks

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.

Minute 9: Test Your Login for Rate Limiting

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).

Minute 10: Grep Your Repo for Committed Secrets

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.

Your Scorecard

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.

Run It Again After Every Big Change

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.

Don't Want to Do It by Hand?

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