the real numberRoughly half of AI-generated code ships with a security hole.
This isn't a vibe. Across large studies of AI-authored code, 40–62% of samples contained at least one security vulnerability, and Georgetown's CSET found 86% failed basic cross-site-scripting defenses. One audit of 5,600 vibe-coded apps surfaced 2,000+ vulnerabilities, 400+ exposed secrets and 175 instances of leaked PII. The reason is structural: models optimize for code that runs, not code that's safe, because unsafe patterns — string-concatenated SQL, missing CSRF, MD5 hashing — are simply more frequent in the training data. The model gives you the most likely code, and the most likely code is insecure.
- 61% of AI samples function correctly; only ~10% pass a real security review.
- AI pull requests carry ~1.7x more issues and 2.74x more XSS than human ones.
- CVEs traced to AI coding tools are growing exponentially — dozens and climbing.
what to actually checkThe six categories where AI code fails — and the gate for each.
A useful checklist is specific. These are the failure modes that show up again and again in AI-generated code, paired with the deterministic check that catches each one. None of them require you to read the diff — they require a structure that runs them every time, which is the whole point.
- Hardcoded secrets — API keys, tokens, credentials baked into source or config. Gate: secret scanning with entropy analysis (Gitleaks/Trufflehog) on every commit, push blocked if it trips.
- Injection (SQL / command / XSS) — string concatenation instead of parameterized queries, unescaped output. Gate: SAST (Semgrep/SonarQube) plus behavioral tests that fire real attacker payloads.
- Broken auth & access control — authentication present but authorization skipped, no CSRF, weak sessions, missing row-level security. Gate: auth-flow tests and policy checks that assert unauthorized requests are actually rejected.
- Hallucinated & vulnerable dependencies — packages that don't exist ('slopsquatting' targets), or real ones with known CVEs. Gate: SCA (Snyk/Dependabot) plus a manifest check that every imported package is real and pinned.
- Weak cryptography — MD5/SHA1, predictable RNGs, hardcoded keys, wrong cipher modes. Gate: lint rules that reject deprecated crypto primitives outright.
- Insecure configuration — permissive CORS, public storage buckets, debug mode in prod, missing security headers. Gate: config linting and a pre-push gate that diffs prod settings against a baseline.
why lists failA checklist a human runs is a checklist that gets skipped.
The honest problem with the PDF-style checklist is the human in the loop. At 3pm on a Friday, under deadline, with an AI cheerfully producing a feature that 'works,' nobody runs eighteen manual checks. They run two, eyeball the rest, and ship. That's how 53% of teams who shipped AI code later found vulnerabilities that 'passed initial review' — the review was a human glancing at a diff they didn't write and couldn't fully reason about. The fix isn't a better-disciplined human. It's removing the human from the position of being the gate. Checks that matter run automatically, deterministically, with zero judgement required — green or it doesn't land.
- Manual review scales with attention; attention is the first thing deadlines take.
- Reviewing code you didn't write is slow and error-prone — the AI's speed is wasted.
- Deterministic gates don't get tired, don't skip Fridays, don't trust a clean-looking diff.
the methodThe Digital Native Method turns the checklist into structure.
Vibe coding — describing software to an AI and shipping what comes back — is genuinely the future of how products get built. The failure mode isn't the AI; it's running it with no structure around it. The Digital Native Method fixes that with a clear split of roles. A Product Owner describes the intended outcome on the live product. A Tech Lead encodes the rules once — your security policy, conventions, the crypto you allow, the dependencies you trust. Then agents implement inside that structure, and every gate above runs before anything merges. The checklist stops being something you remember and becomes something the system enforces on every single change.
- Product Owner: describes intent on the live product — no specs to forget.
- Tech Lead: encodes security rules and gates once; every agent boots inside them.
- Agents: implement; the gates verify; only green code reaches production.
the softwareAgentation is what makes the gates real.
A method is a document until software runs it. Agentation is the tool that applies the Digital Native Method: secret scanning, SAST, dependency checks, auth and config gates run automatically on every change, before it can reach production — and everything ships through your own GitHub, on your existing AI plan. Nothing merges that hasn't passed. You don't run the checklist; the system does, every time, identically. That's the difference between a checklist that documents risk and one that catches it.
- Lint, types, tests and security gates run on every change — not on the ones someone remembers.
- Ships through your GitHub on your own AI plan — your code never leaves your control.
- The Tech Lead's encoded rules mean agents physically can't ship outside policy.
cocoricoSovereign on the tooling — French team, EU stack.
Agentation is built by a French team. We're honest about sovereignty: nobody in Europe is fully sovereign on the frontier models — Claude, GPT — and pretending otherwise is marketing. But the models are only half the story; with raw models alone you don't build much. The orchestration layer — the tool that governs how those models touch your code, what gates run, where your data lives — is where sovereignty is actually winnable, and it's a huge part of the value. Agentation runs on EU infrastructure (Hetzner, Germany), stores data in the EU (Supabase), keeps your code in your own GitHub, and is built GDPR-first. You get frontier-model capability inside a European, accountable, auditable tool.
- Hosting in the EU (Hetzner, Germany); data in the EU (Supabase).
- Your code stays in your GitHub — we never need a copy.
- GDPR-first by design — the gates and the audit trail are part of the product.
FAQWhat should an AI code security checklist actually contain?
Six concrete categories, each tied to an automatic gate: hardcoded secrets (secret scanning), injection — SQL/command/XSS (SAST plus behavioral tests), broken auth and access control (auth-flow and policy tests), hallucinated or vulnerable dependencies (SCA plus a real-package check), weak cryptography (lint rules rejecting MD5/SHA1 and predictable RNGs), and insecure configuration (CORS, headers, public buckets, debug-in-prod). The list matters less than how it's enforced — as gates that run on every change, not items a human ticks.
Why isn't a regular security review enough for AI-generated code?
Because the reviewer didn't write it and the AI produces it faster than anyone can carefully read it. Studies show 53% of teams who shipped AI code later found vulnerabilities that passed initial review. The volume and speed of AI output break human-in-the-loop review. You need deterministic gates that run identically every time, with no reliance on someone being attentive on a Friday afternoon.
What is slopsquatting and how do you catch it?
Slopsquatting is when attackers register malicious packages under names that AI models tend to hallucinate — so when the model invents a plausible-sounding dependency, a real (poisoned) package is waiting under that name. You catch it with a gate that verifies every imported package actually exists in a trusted registry, is pinned to a known version, and passes software-composition analysis against CVE databases before it can be installed in a build.
Do these gates slow down shipping?
They speed it up. Manual review is the slow part — it scales with human attention and stalls under deadline. Deterministic gates run in seconds on every change and either pass or block. You ship faster because you're no longer the bottleneck or the safety net; the structure is. Agentation runs lint, types, tests and security checks automatically before code reaches production, so green code lands without a human gate-keeping each one.
Is my code safe with a French tool that uses Claude or GPT?
Your code stays in your own GitHub on your existing AI plan — Agentation orchestrates the models but doesn't keep a copy of your repository. The tooling, hosting (Hetzner, Germany) and data (Supabase, EU) are European and GDPR-first. We're candid that the frontier models themselves aren't EU-sovereign; the sovereignty you can actually have is on the orchestration layer and your data, which is exactly where Agentation sits.