Large language models used to generate code have stopped improving their security outcomes, according to an analysis published this week by Veracode. The piece, written by CTO Jens Wessling, argues that frontier AI models have consumed nearly all high-quality public code for training and now rely on synthetic outputs or recycled patterns. As a result, the same security flaws—missing validation, unsafe database queries, incomplete access controls—persist across model generations even as other capabilities advance.
The plateau stems from constraints in training data availability and quality, not architecture or computing power. Models now train partly on outputs from earlier models, creating a recursive learning effect where minor flaws replicate and compound over time. The most secure code—found inside financial institutions, healthcare systems, and government agencies—remains private and excluded from training pipelines. That creates a structural gap between enterprise security practices and the publicly available examples models learn to imitate. Meanwhile, AI-generated code introduces vulnerabilities at roughly the same density as human-written code, but its faster generation rate produces a net increase in the total number of security issues entering production systems. Most organizations already can't remediate all identified vulnerabilities, and AI workflows compound both the inflow of new problems and the difficulty of managing them.
The analysis states that security isn't a primary optimization target for these models, which instead prioritize usefulness and plausibility. According to the report, model providers are adding layers such as agents designed to analyze outputs and suggest fixes, but these expansions increase operational complexity and cost while shifting responsibility downstream. The core behavior remains unchanged: models reproduce the patterns present in their training data, including insecure implementations, with no clear path under current approaches to consistently secure output. The report also warns that AI-generated code compresses the traditional boundary between creation and verification, resembling self-attestation where the same class of technology both produces and validates outcomes—a dynamic that doesn't provide sufficient assurance in security contexts.
Organizations can't control how frontier models are trained or what data shapes their behavior, but they do control how AI is used internally and how outputs are validated before deployment. The report recommends treating AI-generated code as untrusted input, subject to the same scrutiny applied to third-party components, through independent validation, continuous testing integrated into development workflows, and governance mechanisms that provide visibility into code generation and deployment. These are established application security principles, and the scale and speed introduced by AI make their consistent application more critical. Incremental model improvements will continue, but they won't fundamentally change the security characteristics of AI-generated code in the near term. The question now, the report concludes, is whether organizations can trust the code they choose to deploy. The shift to AI-assisted development doesn't just accelerate software creation—it forces a reckoning over whether verification infrastructure can scale at the same pace, or whether speed will consistently outrun safety across the industry.