You prompt, the agent writes the code, the app works, you ship it. Somewhere in that loop, nobody actually checked whether the code was safe, just whether it ran. That's not carelessness on your part. It's how vibe coding changes what gets reviewed in the first place. This post breaks down the specific risks hiding in that workflow and gives you a checklist to catch them before your users, or worse, an attacker, does. Minitap's end-to-end regression testing catches what that checklist misses, before your users do.
TLDR:
- Vibe coding lets anyone build working apps fast, but skips security review entirely.
- Researchers found 5,000+ exposed vibe coded apps, 40% leaking sensitive data.
- 99% of organizations using AI-assisted coding suffered an AI-related attack this year.
- Missing authorization checks rarely trip static scanners since nothing looks wrong on the surface.
- Minitap runs functional, end-to-end regression against the live interface as features change shape.
What Is Vibe Coding and Why Teams Use It
Vibe coding happens when someone, developer or not, describes what they want in plain English and lets an AI coding agent write the implementation. Tools like Cursor, Claude Code, Replit, Lovable, and Base44 turn a prompt into working code, often with little manual review of what got written underneath. Andrej Karpathy popularized the term in 2025, and it stuck because it captured something real: coding started feeling less like syntax and more like directing a collaborator toward a "vibe."
The appeal shows up fast. A founder with no engineering team can go from blank screen to working demo in an afternoon. A product manager can test a concept without waiting on a sprint slot. An experienced engineer can scaffold a feature in minutes instead of hours. That speed is why vibe coding spread this quickly among startups and non-technical builders. What gets skipped along the way is covered in detail when looking at vibe coding quality gaps and the rest of this piece.
Why Vibe Coding Creates New Security Risks
Vibe coding changes what the human in the loop actually checks. Traditional AI-assisted development still has an engineer reading the diff line by line before it merges. Vibe coding flips that, raising the question of who verifies AI-generated code: the person prompting often just runs the app and asks whether it works, not whether it is safe. That is a comprehension gap, not a discipline gap. You can review outcomes without understanding the implementation underneath them at all.
Functional correctness and security correctness are not the same target, and AI models are not optimizing for both at once. A model trained to satisfy a feature request will happily produce code that passes every visible test while skipping authentication checks, hardcoding a secret, or trusting user input it should validate. That's a direct result of how context engineering for agents and QA shapes model behavior. Nothing in that process flags the omission, because nothing failed. The app ran. The button worked.
That gap between what the agent wrote and what the developer actually understands is the mechanism behind most vibe coding security risks. It stays invisible until someone with different intent goes looking for it.
The Core Security Risks of Vibe Coding
Vibe coding introduces a handful of recurring vulnerability patterns that show up across nearly every framework these tools touch. Hardcoded secrets are the most common: an agent asked to connect to a database or third-party API will often embed the credential directly in the code instead of routing it through an environment variable, because that's the fastest path to a working demo. Missing or broken authorization checks come next: an agent builds the page that displays a user's data but never verifies the request actually belongs to that user, so anyone who guesses or edits the URL gets the same view. Unvalidated user input opens the door to injection flaws, since an agent optimizing for a passing test rarely adds the sanitization step that stops a malicious string from reaching a database query or an on-screen page. Dependency risk follows a similar pattern: agents will import a package by name without confirming it's the real, maintained library, and that name-only match is exactly the kind of gap an outdated or malicious package can exploit. Each of these risks looks identical to working code from the outside, which is precisely why they slip past vibe coding's usual review step of just running the app.
| Risk | What It Looks Like | Why It Slips Through |
|---|---|---|
| Hardcoded secrets | Agent embeds an API key or database credential directly in the code instead of an environment variable. | It's the fastest path to a working demo, and the app still runs fine. |
| Missing or broken authorization checks | A page displays a user's data but never verifies the request belongs to that user. | Anyone who guesses or edits the URL gets the same view, and nothing looks broken. |
| Unvalidated user input | No sanitization step is added before user input reaches a database query or on-screen page. | The agent optimized for a passing test, not for blocking injection. |
| Dependency risk | A package is imported by name without confirming it's the real, maintained library. | The name-only match is exactly the kind of gap an outdated or malicious package can exploit. |
Real-World Vibe Coding Incidents
Security researcher Dor Zvi and his team at RedAccess analyzed thousands of vibe coded web apps built on Lovable, Replit, Base44, and Netlify and found more than 5,000 with virtually no security or authentication of any kind. Anyone who found the URL could get in, and some apps asked for nothing more than an email before handing over the goods. Around 40 percent of those apps exposed sensitive data, including medical information, financial records, corporate presentations, and strategy documents. These were live and reachable by anyone who stumbled on the link.
Palo Alto Networks' State of Cloud Security Report found that GenAI-assisted vibe coding is now used by 99% of surveyed organizations, and separately, 99% had experienced an attack against their AI apps and services in the past year. Adoption outran review capacity, and the apps sitting exposed on the open web are the receipt.
Is Vibe Coding Safe? What Benchmarks Show
Independent benchmark testing tells the same story as the incident data above: security correctness and functional correctness get measured on different axes, and most vibe coding tools are optimized almost entirely for the second one. When researchers run AI-generated code samples against security-focused test suites instead of just functional test suites, the code that passes every feature check still fails checks for missing authorization, injection handling, and secret management at a meaningful rate. That pattern holds across different models and different vibe coding platforms, which points to something structural in how these models are trained and scored instead of a quirk of one tool or vendor. It also makes the failure mode predictable instead of random: the same categories of missing checks, authorization, input validation, hardcoded secrets, dependency verification, show up benchmark after benchmark, which is exactly the list this piece keeps coming back to. The practical takeaway is that no vibe coding platform currently ships a benchmark result that would support skipping a dedicated security review before merge.
What Developers Say on Reddit and GitHub About Vibe Coding Security
Search vibe coding security threads on Reddit and the same pattern repeats: a developer posts a working app built entirely through prompts, and the top comment asks whether they checked for exposed API keys or open database rules before shipping it. On r/webdev and r/ExperiencedDevs, the recurring complaint isn't that the agent writes obviously broken code, it's that the person prompting has no reliable way to tell insecure code from secure code just by reading the output, since both run and look identical on the surface. GitHub tells a smaller version of the same story: pull requests generated by tools like Cursor and Claude Code get flagged in review for hardcoded credentials or missing input validation, the kind of issue a human engineer would typically catch before ever opening a PR. The failure mode maintainers describe most often is an agent that solves exactly the problem it was asked to solve and nothing more, so a prompt to add a login page produces a login page with no rate limiting and no session expiration unless someone thinks to ask for those explicitly. Enough of these threads point to the same root cause: a specification gap. The tools build what they're told, and security requirements are rarely part of the instruction.
A Vibe Coding Security Checklist
Before merging anything a vibe coding agent wrote, run it through the same six checks, in order.
- Scan for hardcoded secrets. Search the diff for API keys, tokens, and passwords written directly into code or config files. Agents reach for the fastest working solution, and that often means a credential sitting in plain text.
- Verify every dependency actually exists. Check package names against the real registry before installing anything an agent suggested. A plausible sounding library that nobody maintains, or that doesn't exist at all, is an open door.
- Review authentication on every user-facing endpoint. Confirm access control was implemented, not assumed. Vibe coded apps have shipped with no login requirement at all.
- Run static analysis and runtime testing before merge. Automated scanning catches injection flaws, insecure defaults, and missing input validation that a quick manual read will miss.
- Require sign-off on security-sensitive paths. Anything touching auth, payments, or personal data needs a reviewer who understands the code, beyond someone confirming the feature works.
- Set cloud budget and usage alerts. Runaway agent behavior, like an infinite loop hitting a paid API, shows up in the bill before it shows up anywhere else.
How to Catch Vibe Coding Vulnerabilities Before Production
Static analysis and dependency scanning catch known vulnerability patterns and packages with published CVEs. Vibe coding's failure modes often live somewhere else. A missing authorization check is not a pattern match, it is a gap in business logic that only surfaces when someone tries to access a resource they should not reach. That's exactly the category of issue that AI QA testing is designed to expose. Broken access control, a validation step skipped under one condition, an endpoint that trusts a role claim it should verify: none of that trips a signature-based scanner, because nothing about the code looks wrong on its face. It just behaves wrong.
Conversational development compounds the gap. Code changes faster than a reviewer can read every diff for meaning instead of syntax, which is why understanding what a mobile QA agent actually does matters here, and a one-time security review scheduled before release is already behind the pace at which these agents generate new surface area.
Closing the gap means testing the running app the way a real user, or attacker, would. Runtime testing exercises the app itself, catching a missing authorization check the moment something tries to access a resource without permission. Agentic testing has to run on every change, not as a pre-release gate. Comparing what shipped against the documented requirement catches the quiet deviations a functional test would pass.
How Minitap Strengthens Vibe Coding Security
Static review checks the code an agent wrote. It cannot confirm what that code does once a real user opens the app and starts clicking. Vibe coded features change shape fast, often across a single prompt-and-regenerate cycle, and a test suite built from predefined scripts breaks at the same pace for the same reason manual review breaks down, a pattern covered in depth in AI mobile app testing and human oversight: the thing being tested does not hold still long enough for a fixed checklist to stay accurate.
Minitap is an AI QA employee that runs functional, end-to-end regression against the actual interface instead of scripts written for a previous version of the feature. Its mobile-use agent achieves state-of-the-art performance on AndroidWorld, a recognized benchmark for autonomous agents on real mobile tasks, solving 100 percent of the test suite, closing the QA gap that AI dev tools create. Where a pass/fail script stops at the first unexpected screen, Minitap investigates and surfaces the flow, the screen, and the reason it broke. Connect the codebase at minitap.ai and let the QA loop run itself.
FAQ
What are the most common vibe coding security risks I should check for before shipping?
The four failure patterns that surface consistently across vibe coded apps are hardcoded secrets, missing authorization checks, unvalidated user input, and unverified dependencies. Each one looks identical to working code from the outside because the app still runs fine. A security researcher analysis of apps built on Lovable, Replit, Base44, and Netlify found more than 5,000 with no authentication at all, with roughly 40 percent exposing sensitive data including medical records and financial documents. Running a dedicated scan against these four categories before merge is the minimum bar. Minitap covers the category a scan alone cannot: it runs functional, end-to-end regression against the live interface, catching a missing authorization check the moment something tries to reach a resource without permission.
Is vibe coding safe to use for production apps, or do benchmarks show it creates security holes?
Vibe coding tools are optimized for functional correctness, not security correctness, and independent benchmark testing confirms the gap. Code that passes every feature check still fails checks for missing authorization, injection handling, and secret management at a meaningful rate across multiple models and platforms. Palo Alto Networks found that 99 percent of organizations using AI-assisted coding experienced an AI-related attack in the past year. No vibe coding tool currently ships a benchmark result that supports skipping a dedicated security review before merge. Minitap is the dedicated security review that keeps pace: it runs functional, end-to-end regression against the actual running interface, catching the authorization and validation failures benchmark testing shows slipping through vibe coded apps.
What does a vibe coding security checklist need to cover?
A pre-merge checklist needs six checks in order: scan for hardcoded credentials in the diff, verify every dependency against the real registry, confirm authorization is implemented on every user-facing endpoint, run static analysis and runtime testing, require sign-off on any path touching auth or payments, and set cloud budget alerts to catch runaway agent behavior. Missing authorization checks are the category most likely to slip past a quick manual read because nothing in the code looks wrong on its face. It just behaves wrong when someone with different intent goes looking. Minitap owns the runtime testing step on that list: it runs functional, end-to-end regression against the live app and surfaces exactly which flow, screen, and permission check broke.
How do I catch vibe coding vulnerabilities that static scanners miss?
Static analysis catches known patterns and published CVEs. It does not catch a missing authorization check, because that is a gap in business logic and not a pattern match. Nothing about the code looks wrong; it just behaves wrong when someone tries to access a resource they should not reach. Minitap closes that gap by running functional, end-to-end regression against the actual running interface the way a real user or attacker would, catching broken access control and skipped validation steps the moment something tries to reach a resource without permission. Its mobile-use agent achieves state-of-the-art performance on AndroidWorld, solving 100 percent of the tested task suite, and it ships evidence, root-cause analysis, and next actions with every failure it finds.
What's the best way to keep up with vibe coding security as features regenerate every prompt cycle?
Vibe coded features change faster than a one-time pre-release gate can track, so the testing approach has to run on every change and not on a fixed schedule. Minitap runs functional, end-to-end regression against the actual interface without requiring predefined scripts, which means it stays accurate as features regenerate across prompt cycles without your team rewriting selectors or updating test cases. Connect your codebase at minitap.ai and let the QA loop run itself.
Final Thoughts on Vibe Coding and Its Security Blind Spots
Vibe coding will not slow down, and neither should your effort to catch what it misses. The checklist gives you a starting point, but the real fix is testing the running app the way someone with bad intent would. Your features change fast, and your safety net should change just as fast to keep up. Connect your codebase to Minitap and let that testing run on its own.