Check your own app — free, in about a minute.
Don't guess from a checklist — run the outside-in checks on the app you're about to ship: its live headers, TLS, exposed files, backend rules and any keys leaked into the client bundle, ending in a score and a shareable result page. No account, no card.
Run the free mini-scan →You described your app in plain English. An AI wrote the code. It works. It looks great. You shipped it.
Here's the problem nobody mentions: AI coding tools optimize for working software, not secure software. The code runs, the demo impresses — and buried inside are the same vulnerabilities that have been getting apps breached for twenty years.
Below are the seven holes that show up most often in AI-generated apps, what they look like, and how to check for each.
This is the single most common issue. You tell the AI "add Stripe payments" or "use the OpenAI API," and it does — by pasting your secret key directly into frontend JavaScript where anyone can read it with View Source.
What it looks like: A .env file that never got created. A const STRIPE_SECRET = "sk_live_..." sitting in a bundled JS file. An API key committed to a public repo.
Why AI does this: The model is optimizing for "it works when I run it." Environment variables and server-side proxies are extra steps that don't improve the demo. Unless you explicitly ask for secure secret handling, you usually don't get it.
How to check: Open dev tools, go to the Sources tab, and search your bundled JavaScript for sk_live, api_key, secret, token, or AKIA. Anything that looks like a credential is exposed. Move secrets server-side and proxy API calls through your backend.
Parameterized queries have been the standard defense for decades. AI-generated code sometimes uses them — and sometimes doesn't, especially when building dynamic search filters, sort options, or admin queries where string concatenation feels "easier."
What it looks like: Code like query = "SELECT * FROM users WHERE name = '" + searchInput + "'" — or a query builder interpolating user input.
Why AI does this: When you ask for "a search feature that filters by any column," the straightforward implementation is string building. The model knows about parameterized queries, but under vague instructions it picks the path of least resistance.
How to check: Search your codebase for raw SQL strings concatenated with variables. Any query built with +, template literals, f-strings, or .format() touching user input is suspect. Rewrite with parameterized queries or your ORM's safe methods.
AI tools will happily build you a login page. Whether the authentication actually protects anything is a separate question. Common failures: routes that check auth on the frontend but not the backend, JWTs validated nowhere, "admin" pages hidden by obscurity (an unlinked URL), and session tokens that never expire.
What it looks like: A beautiful login form guarding an API that accepts unauthenticated requests. An /admin route that returns data to anyone who guesses the URL.
Why AI does this: Frontend auth is visible and demoable. Backend auth is invisible plumbing. Guess which one gets prioritized.
How to check: Log out, then try to hit your API endpoints directly with curl or Postman. Try the admin URLs. If anything returns data without a valid session, your auth is decorative.
Your app has URLs like /api/orders/1234. What happens when a logged-in user changes 1234 to 1235? If they see someone else's order, you have an IDOR — the app checks that you're logged in but never checks whether the thing you're asking for belongs to you.
What it looks like: API endpoints that take an ID from the URL or request body and return the record without verifying ownership.
Why AI does this: Ownership checks are business logic, and the AI doesn't know your business logic. "Get order by ID" is a complete-sounding instruction. "Get order by ID if it belongs to the current user" is the version that requires you to think like an attacker.
How to check: Create two test accounts. With account A logged in, request resources that belong to account B by guessing IDs. If you get data back, you have a problem.
Anywhere your app displays user input — comments, profile names, search results, chat messages — is a potential XSS vector if that input isn't properly escaped. AI-generated apps frequently render user content with innerHTML, dangerouslySetInnerHTML, or unescaped template output.
What it looks like: A comment section where posting <script>alert(1)</script> actually runs. A username field that lets you inject HTML into other users' pages.
Why AI does this: innerHTML is the fast way to render dynamic content, and tutorials are full of it. Proper escaping requires the AI to choose the slightly harder path.
How to check: Enter <img src=x onerror=alert('xss')> into every text field in your app — comments, names, bios, search boxes. If an alert fires anywhere, you have stored or reflected XSS.
AI assistants love adding debug routes (/debug, /test, /api/__health__) and detailed error pages while building. They're useful during development. They're also frequently still there in production, leaking stack traces, environment details, database schemas, and internal paths.
What it looks like: A production error page showing a full stack trace with file paths. A /debug/env endpoint happily listing configuration. Console logs full of internal state.
Why AI does this: Nobody told it to clean up. "Remove all debug code before launch" is a step that exists in nobody's vibe-coding prompt.
How to check: Trigger errors on purpose — bad URLs, malformed input, huge payloads. Read what comes back. Then search your routes for debug, test, dev, admin, and health endpoints you didn't intend to ship.
Your login form, your contact form, your API — can someone hit them ten thousand times a minute? Without rate limiting, the answer is usually yes. That means credential stuffing against your users' accounts, form spam, and API abuse are all trivially easy.
What it looks like: An API with no throttling headers, no request caps, no lockouts. A login endpoint that happily accepts a thousand password guesses.
Why AI does this: Rate limiting is pure infrastructure — invisible, unsexy, and never part of "make me a login page." It simply doesn't occur to the model unless asked.
How to check: Write a five-line script that hits your login endpoint 100 times in a loop. If all 100 go through without a 429 or captcha, you have no meaningful rate limiting.
Notice the thread connecting all seven: AI coding tools build what you described, and security is almost never in the description. Every one of these is a case where the "obvious" implementation skips a step a security-minded developer would consider mandatory.
You don't need to become a security expert before shipping. You need a second pair of eyes — one that thinks like an attacker — before your app meets the internet.
PreShipIt probes your app the way an attacker would and gives you a plain-English report of what to fix. No security background required.
$29, one-time. No subscription. Scan your app 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.
Don't guess from a checklist — run the outside-in checks on the app you're about to ship: its live headers, TLS, exposed files, backend rules and any keys leaked into the client bundle, ending in a score and a shareable result page. No account, no card.
Run the free mini-scan →← Back home · Run a free mini-scan · Scan my app — $29 · See a sample report