Varun Badhwar is CEO & Co-Founder at Endor Labs. Previously, he built Prisma Cloud for Palo Alto Networks following the RedLock acquisition.
getty
AI coding agents are no longer experimental tools sitting on the edges of software development. They are writing, reviewing and shipping production code across nearly every major enterprise. The productivity gains are undeniable, and the pressure to move quickly with these systems has never been higher.
But there’s a dangerous assumption embedded in how most organizations are measuring success: that code that works is code that’s safe.
That assumption is already breaking down. My team recently benchmarked AI coding agents across hundreds of real-world open-source tasks spanning dozens of vulnerability classes. The findings were striking. Most AI-generated code successfully passed functional tests, but only a small fraction of it was actually secure. An even smaller percentage was both functionally correct and secure at the same time.
What stood out most was the trajectory. Functional performance is improving rapidly across frontier models while security performance is barely moving.
The industry has seen this pattern before. Security was treated as an afterthought during the early web era, then again during the cloud transition. Each time, organizations prioritized speed first and assumed security controls could be layered in later. Each time, the result was years of breach cycles and operational disruption while the ecosystem tried to catch up.
The difference now is that AI compounds the problem at machine speed. These systems are trained on publicly available source code pulled from open-source repositories. Some of that code reflects excellent engineering practices. Some of it contains insecure patterns, outdated dependencies and vulnerable architectures that have existed in the ecosystem for years. AI agents absorb all of it indiscriminately and replicate those patterns at scale.
A Structural Problem, Not A Tooling Problem
Insecure development practices are no longer isolated to individual developers making occasional mistakes. They can now propagate automatically across thousands of repositories, generated continuously by systems optimized primarily for functionality and velocity.
At the same time, the broader threat landscape is accelerating in parallel. Recent industry reporting showed vulnerability exploitation surpassed stolen credentials as the leading initial breach vector for the first time in nearly two decades. Meanwhile, attackers are increasingly using AI to compress time-to-exploit from months into hours. Organizations now deal with a software ecosystem where vulnerabilities are being created faster, discovered faster and exploited faster than traditional security programs can realistically respond to.
AI Coding Agents Make Attack Surface Even More Dynamic
The scale of the problem becomes clearer when looking at the volume. The number of vulnerability instances across modern software environments has exploded over the last several years, driven largely by open-source adoption and dependency sprawl. Third-party software involvement now appears in nearly half of reported breaches. The supply chain is no longer a secondary security concern; it has effectively become the attack surface itself.
The issue is not simply that AI writes insecure code. It’s that the surrounding workflows increasingly remove the natural pause points that historically slowed risk propagation. Dependencies are pulled automatically. Packages are updated dynamically. Agents can generate code, install libraries and trigger downstream workflows with minimal human review. In many organizations, insecure patterns can move from prompt to production before security teams even know they exist.
Three Shifts That Can’t Wait
This is why the industry needs to rethink several core assumptions about software security:
1. Security controls have to move directly into the developer workflow.
If security review begins at the pull request stage, organizations are already operating too late in the life cycle. By that point, the dependency has already entered the codebase, the insecure pattern has spread and remediation becomes significantly more expensive operationally.
2. Organizations need to move away from prioritizing vulnerabilities purely through severity scoring.
In high-volume AI-driven environments, severity without context becomes noise. The more important question is whether a vulnerability is reachable and actively exploitable within the application itself. A medium-severity issue sitting directly on a production execution path may represent far greater risk than a critical vulnerability buried in unreachable code.
3. Security teams need to be measured differently.
Historically, AppSec programs have focused heavily on reporting issues, managing backlogs and tracking SLA compliance. That model does not scale in environments where software is generated continuously by agents operating at machine speed.
The teams that will succeed over the next several years will not be the ones producing the largest backlog reports. Instead, they will be the teams capable of orchestrating fixes automatically, validating changes continuously and reducing exploitable risk in real time.
AI-generated software is not slowing down, and organizations should not try to fight that shift. The productivity benefits are too significant, and the competitive pressure is too high. But the current trajectory is unsustainable if security continues operating with assumptions designed for a slower era of software development.
The future of software security will not be defined by who ships the most code. It will be defined by who can still understand and control the systems they are generating.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
>> Home