The Cloud Security Alliance published a research note this month with a title that should stop you mid-scroll: "AI-Generated CVE Surge." The finding underneath it: 91.5% of over 200 vibe-coded applications contained at least one vulnerability traceable to AI hallucination. Not a logic bug. Not a UI glitch. A security vulnerability — the kind that gets a CVE number and a disclosure timeline.
Vibe coding hit 92% daily adoption among developers in the first half of 2026. Describe what you want in plain English, accept whatever the model produces, ship it. The productivity gain is real. So is the trail of XSS, injection, and broken auth it's leaving behind.
We wrote two weeks ago about AI-generated code shipping with 1.7–2.7x more defects than hand-written code. Vibe coding is the extreme end of that spectrum — the part where the developer stops reading the output entirely. The AI writes it, the AI looks right, it runs, it ships.
The security numbers at that extreme are worse than the general case:
These aren't edge cases in toy apps. These are the patterns that show up when authentication logic, session handling, and input validation are written by a model that optimizes for "looks correct" rather than "is correct."
Here's the part that makes this a testing problem, not just a coding problem: when the same AI writes the code and the tests, both outputs share the same blind spots.
An LLM that doesn't understand why a session token needs to be HttpOnly will generate code without the flag and a test that doesn't check for it. The test passes. The vulnerability ships. The test didn't fail — it never knew what to look for.
This is the "same-source" problem, and it's specific to vibe coding. A human developer who writes a login flow has mental context about what "secure" means in their stack. They might forget to check the cookie flags, but they know the flags exist. An AI that generates both the implementation and the test generates a closed system where the gap in one is invisible to the other.
Only 29% of developers say they trust vibe-coded output. But 92% use it daily. The trust gap isn't stopping anyone — it's just making the testing problem someone else's problem. Specifically, the production user's problem.
Most test suites verify that a flow works — the user logs in, the dashboard loads, the button does the thing. They don't verify that the flow is secure. A mocked test doesn't know whether the real server set the right CORS headers. A stubbed auth response doesn't reveal that the session token is predictable. A unit test on the signup function doesn't check whether the password hash actually uses bcrypt or a model-hallucinated call to md5().
Security flaws in vibe-coded apps don't live at the interface level. They live in the implementation details — the response headers, the cookie attributes, the redirect chains, the token lifecycle. The only way to catch them is to run the actual flow against the actual app and inspect what actually came back over the wire.
This is the gap between "does it work" and "is it safe." A test that only answers the first question gives you a green suite and a vulnerability scanner full of findings.
A proxy-level test sees everything the browser sees: every header, every cookie, every redirect. When a vibe-coded auth flow skips the Secure flag on a session cookie, the proxy captures it. When a payment redirect leaks a token in a query parameter, the proxy logs it. When a CORS misconfiguration lets any origin read the response, the proxy shows the Access-Control-Allow-Origin: * header that the mocked test never sent.
This is why Test Chain runs as a proxy instead of generating test scripts. A generated script tests the interface — the same interface the AI already tested when it wrote the code. A proxy tests the implementation — the part the AI got wrong and the AI-written test didn't catch.
Record the flow. Replay it against the real app. Look at what came back. The CVE that the Cloud Security Alliance is worried about lives in the response, not in the assertion.
The industry spent 2025 debating whether AI would replace testers. In 2026, the question is sharper: who's testing the AI's work? Not whether an agent can write a test — but whether any test, written by any agent, is actually checking the thing that's broken.
Ninety-one percent of vibe-coded apps have a vulnerability. Ninety-two percent of developers are vibe-coding daily. The intersection of those two numbers is the attack surface that's shipping to production right now, behind a green test suite that tested the wrong layer.
The fix isn't to stop vibe coding. The productivity gain is too real for that. The fix is to stop trusting the same system that wrote the code to also verify it — and to test against the real thing, where the vulnerabilities actually live.