AI models are improving at finding and exploiting vulnerabilities while AI coding tools expand the amount of code being produced.
2
Most vulnerabilities found by frontier models belong to old classes that teams already know how to prevent, including memory-safety bugs.
3
Security teams should add guardrails to AI coding, prevent flaws before pull requests, harden open-source foundations, and rewrite critical software where appropriate.
Summary
Jack Cable argues that defenders face two changes at once: AI models are getting better at finding and exploiting vulnerabilities, while coding agents are producing more software with less direct human oversight. He says this does not mean every vulnerability is new. Many belong to familiar classes such as buffer overflows, and memory-safe languages can prevent large portions of those bugs. The harder problems are often contextual, such as authorization errors that depend on proprietary business logic. Cable recommends using AI to review and secure code before pull requests, while giving security teams visibility and guardrails rather than blocking coding agents. He also calls for systemic work on open-source foundations, including rewrites of critical libraries, and wider access to powerful open-weight models so defenders can use them. His argument is practical: patching individual findings will not keep pace with autonomous attack and development systems.
AI is improving at both vulnerability discovery and autonomous exploitation
Cable says frontier models are finding and exploiting vulnerabilities in open-source libraries that support much of today's software. At the same time, AI coding tools are expanding the attack surface because they are becoming the default code writer. Developers are moving beyond autocomplete and synchronous assistance inside tools such as Cursor. They can now start many agents from Slack or other work environments and let them run in the background. Cable expects adversaries to automate the full attack process, from finding a flaw through exploitation, so defenders need to identify where systems can resist those attack chains.
The vulnerabilities models find are usually old classes with known defenses
Cable's positive case is that frontier models are not discovering entirely new categories of bugs. They are finding specific instances of vulnerability classes that security teams have understood for decades. He points to MITRE classes appearing among vulnerabilities in CISA's known exploited vulnerabilities catalog, including buffer overflows. Memory-safe languages such as Rust and Go provide guarantees that prevent memory-safety vulnerabilities from being introduced. Cable's conclusion is that teams can use the growing power of AI to address recurring classes systematically instead of treating every model-found flaw as an isolated surprise.
Memory-safe languages can reduce recurring vulnerabilities before they exist
Cable says approximately 60 to 70 percent of vulnerabilities in products written in memory-unsafe languages can be prevented by using memory-safe languages. He cites work by Google, Microsoft, and Amazon, along with parts of the Linux kernel being rewritten in Rust. A Google chart on Android shows memory-safety vulnerabilities falling from about 75 percent in 2019 to about 30 percent in 2022, even though the project was adding new memory-safe code rather than rewriting everything. For Cable, this supports one-time architectural changes that keep reducing risk over time.
AI-generated code still fails on context-heavy security problems
Cable cites the Backsbench benchmark from researchers at ETH Zurich and UC Berkeley, where the best models introduce vulnerabilities about 20 to 40 percent of the time when writing code. He says models learn from existing code, and humans have historically put many vulnerabilities into that code. The failures are increasingly contextual rather than simple one-line mistakes. Authorization bugs are an example because they require knowledge of a company's business logic and threat model. A model can be highly capable and still lack the proprietary context needed to recognize that its change is unsafe.
Security teams need guardrails around autonomous coding agents
Cable describes a progression from autocomplete to agents inside Cursor and Claude Code, followed by agents that can work for hours and produce large changes. He expects most shipped code to be reviewed by AI rather than a human within six to twelve months, because code review is becoming a development bottleneck. His recommendation is to prevent vulnerabilities before the pull request and give security teams visibility into how coding tools are used. The goal is not to deny developers access to agents. Teams need controls that let engineers move faster while giving security staff enough assurance to approve more autonomous development.
Cable says open-source software will be a proving ground for adversaries because attackers can run capable models against code that is publicly available. He argues that government and private companies should help harden this foundation. Finding and patching individual vulnerabilities matters, but it will not address the repeated introduction of familiar bug classes. Cable favors larger changes, such as rewriting critical libraries in a memory-safe language, because those changes can reduce the flaws that models can find now and later. He also recommends preventing vulnerabilities in newly generated code as development accelerates.
Cable wants defenders to have broad access to powerful open-weight models
Cable says the benefits of powerful models for defenders outweigh their risks, even though the same systems can help attackers. He points to safeguards in Anthropic's Fable release and to distillation attacks that let open-weight providers train on closed-weight model outputs. That process is shrinking the time between a frontier closed-weight release and open-weight models catching up. Since adversaries already have access to powerful systems, Cable argues that defenders need access too. He recommends an ecosystem of American-made open-weight models, partly because companies may need to fine-tune models, which requires access to model weights.
"It really has to be more systemic and start to get into rewrites that can fundamentally reduce the risk of vulnerabilities."17:42
Who should watch
You are responsible for security while your engineering organization is adopting coding agents and need controls that do not simply block their use.
Your team maintains open-source libraries or critical infrastructure written in memory-unsafe languages and needs to weigh one-time rewrites against repeated patching.
You work on AI policy or model access and want Cable's case for giving defenders access to powerful open-weight systems.
