The state of play, in figures and sources
By 2026, several independent studies stopped talking about impressions and started measuring. The most-cited finding fits in one sentence: only about 35% of AI-generated backend code is both secure AND correct according to empirical evaluations. In other words, in a majority of cases the code produced is either wrong, or vulnerable, or both, even when it 'looks' like it works.
The share of code containing at least one vulnerability is estimated between 62% and 92% depending on the study. That is a wide range, and it should be read as one: methodologies differ (languages tested, definition of a vulnerability, severity threshold, prompt corpus). No single number from that range should be quoted in isolation without naming the study and its method; it is the range, not a point, that is the honest figure.
The risk is not theoretical. Georgia Tech's 'Vibe Security Radar' records CVEs tied to AI-generated code accelerating sharply through the first quarter of 2026: 6 in January, 15 in February, 35 in March, which, over those three months, is more than all of 2025 combined.
On perception, distrust tracks the numbers: 87% of developers say they doubt the reliability of AI-generated code. Those who use it most are often the first not to trust it blindly.
A methodological caveat, in fairness: this corpus is mostly industry security research, security-firm reports, audits, benchmarks, not a body of peer-reviewed academic literature. Only one genuinely academic work is in it (an arXiv paper); the rest comes from industry. That does not make the figures wrong, but it means reading them for what they are: convergent independent measurements, not a settled scientific consensus.
One of these works is worth naming, because it frames the debate exactly: the independent Vibe-Eval benchmark (2026) catalogs the failure modes of several mainstream generators, Lovable, Bolt, Cursor, Replit, v0, on application-security criteria. That is precisely the ground on which an engine that publishes a dated runtime validation can measure itself head-on, rather than falling back on trust.
- ~35% of AI-generated backend code is both safe and correct (empirical evaluations).
- 62% to 92% of generated code contains vulnerabilities, wide range, differing methods.
- Related CVEs: 6 → 15 → 35 per month (Jan → Mar 2026, Vibe Security Radar, Georgia Tech).
- 87% of developers doubt the reliability of AI-generated code.
Why: a probabilistic model produces plausible code, not guaranteed code
The cause is structural, not temporary. A large language model produces the most probable token given the context. Applied to code, that yields the most likely continuation, not necessarily the correct one, nor the safe one. The model has no internal notion of 'this schema compiles', 'this query is parameterised', 'this access control exists'; it has a notion of 'what code of this kind looks like'.
That is exactly what makes the problem insidious: hallucinated code is plausible. It reads well, sometimes compiles, deploys, and fails in use, or worse, appears to work while leaving an SQL injection, a hard-coded secret, a missing authorisation check. The recurring flaw categories documented by the studies (injection, poor secret handling, missing input validation, broken access control) are precisely those a model reproduces because they abound in its training data.
Adding an instruction to the prompt ('write secure code') shifts the probabilities, but does not change the nature of the object: nothing guarantees the result, because nothing verifies it. An instruction is not a proof.
The distinction that changes everything: the AI writes the specification, a builder compiles the code
Blueprint Maker starts from this observation and refuses to let the model write the code. The pipeline separates two roles that nothing forces us to merge. The AI does what it does best: understand a business domain and produce a structured specification, a schema of entities, relations and rules, in JSON. It designs; it does not code.
Then deterministic builders, written once, tested, versioned, turn that specification into code: database schema, screens, routes, dashboards. The code is therefore never 'hallucinated' by the LLM: it is produced by a program whose behaviour is known. Component properties are not guessed, they are derived from the specification by fixed rules. The same input specification always produces the same output code.
This separation does not magically remove all risk, but it moves the problem to where it is tractable: instead of hoping a probabilistic model introduced no flaw across thousands of unique lines, we guarantee by construction that the code patterns (queries, forms, controls) come out of a single, auditable generator that can be fixed once and for all.
- The AI → understands the domain → produces a specification (not code).
- Deterministic builders → compile the specification → produce the code.
- The code is not inferred line by line by the model: it is generated by a known program.
The accountable defence: published runtime validation (K-15 / Health Score)
Writing code by a safer method stays a promise until you prove it. The decisive difference is not to claim 'our code is reliable', it is to measure it and publish the measurement. Every application produced by Blueprint Maker passes an automated runtime validation, called K-15: the code is compiled, the application actually started, then walked through screen by screen by an automated browser. The criterion is binary: it runs, or it doesn't.
The aggregate result, the share of applications that pass all of these checks over a rolling seven-day window, is published and dated under the name Health Score. It is an accountable reliability metric: verifiable, non-declarative, produced by an automated judge rather than a marketing claim.
This is precisely what no purely probabilistic generator publishes, and for a fundamental reason: producing such a measure requires a deterministic, reproducible way to test each output under real conditions. A pipeline that lets the model write the code and ships it as-is has no systematic runtime gate to display. Transparency about reliability is only possible if reliability is built to be measured.
Our limits, honestly
Runtime validation proves that an application builds, starts and can be navigated correctly; it sharply reduces the 'plausible-but-broken code' class of errors. It does not replace a full application security audit, a penetration test, or a compliance review. Blueprint Maker does not, to date, claim a SOC 2 or ISO certification: we prefer to publish a real, dated metric rather than a badge that says nothing about the product shipped.
The right reading is this: AI-generated code has a measured reliability problem; the only credible answer is not a promise but a published verification; separating design (the AI) from fabrication (deterministic builders) makes that verification possible and reproducible. It is a foundation, not a blank cheque, and it beats a number you don't show.
Sources
Cloud Security Alliance, Vibe Coding / AI Governance Gap: https://labs.cloudsecurityalliance.org/research/csa-research-note-vibe-coding-ai-governance-gap-20260602-csa/
The Security Crisis in AI-Generated Code (2026): https://blog.vibecoder.me/security-crisis-ai-generated-code-2026
IOActive, The Security Gap in AI-Generated Code: https://www.ioactive.com/wp-content/uploads/2026/05/IOA-The-Security-Gap-in-AI-Generated-Code.pdf
AppStuck, AI-Generated App Security Risks (2026): https://www.appstuck.com/blog/ai-generated-app-security-risks
Vibe-Eval, AI App Security Benchmark 2026: https://vibe-eval.com/data-studies/ai-app-security-benchmark-2026/
Sherlock Forensics, AI Code Security Report 2026: https://www.sherlockforensics.com/pages/ai-code-security-report-2026.html
OX Security, Vibe Coding Security: https://www.ox.security/blog/vibe-coding-security/
arXiv, Coding With AI: https://arxiv.org/pdf/2512.23982