Manoj Nair, CTO & Chief Innovation Officer at Snyk
“We don’t have a cybersecurity problem. We have a software quality problem.” This was true when Jen Easterly, former director of the Cybersecurity and Infrastructure Security Agency, said this at the BlackHat security conference in 2024. Agentic development has made it even more true today.
“Shift left” began a decade or so ago with a simple bet: every defect is dramatically cheaper and easier to fix the closer it sits to the moment of creation. Traditional application security (AppSec), which had already spent two decades evolving before “shift left” arrived, had become something else entirely: a gatekeeper and auditor that measured software after the fact. In the hurry to ship, the late-stage process fixed what it could and became a CYA mechanism for everything left in the backlog. That model was tolerable for two reasons that no longer exist. First, humans wrote the code at linear rates, so the volume of new issues remained manageable. Second, attackers were resource-constrained, and they largely ignored lower-severity findings because they lacked the time and tooling to chain them. Both conditions have since broken.
The deeper assumption that broke was scarcity. Traditional AppSec was built to ration one scarce resource: human attention. The backlog was the residue of that rationing, a running list of everything we decided we did not have time to fix. Agents removed the scarcity of labor. The only scarce thing left is human judgment, and it belongs in setting the bar, not working the ticket.
Analysis of CVE.org and National Vulnerability Database data shows that the number of new security issues reported has increased dramatically in 2026. At the same time, autonomous attack agents are no longer a research curiosity, and recent containment failures at frontier labs have shown models taking unsanctioned action against real systems. The attacker is no longer resource-starved, and the assumption that you can defer the backlog is now an active liability.
Software factories changed the physics
What is happening is not incremental acceleration of the old model. Software factories are a fundamental redefinition of how software gets built. Specs go in, and agents write, revise, test and ship the code. Humans set intent, review outcomes and govern the system. The primary author of much of today’s code is no longer a person you can train, review or hold accountable.
Under waterfall, AppSec was a gate at the end. Agile turned the gate into a recording system that let you proceed. “Shift left” moved the work of finding and fixing issues closer to the time of creation and helped people writing the code produce secure code and use dependencies without known vulnerabilities. That was the right response for its moment because most software developers had never been trained in safety the way engineers in other disciplines were. “Shift left” reduced the distance between introduction and remediation for human-authored software, and the results showed that it worked.
But it is no longer sufficient.
Even the best models still produce fully correct and secure backends well under half the time. BaxBench showed the strongest models reaching roughly 60% functional correctness, with a large share of those correct solutions remaining insecure. Velocity has risen by an order of magnitude, but the quality floor has not. As the developer’s role shifts from primary author to orchestrator and approver, the attacker is changing along with it.
Prevention only works if you “shift in”
The only way to stop the debt loop of find-and-fix is to put security inside the agentic loop of creation itself; that is what “shift in” means. If agents are writing the code, the security context, bounds and feedback have to be inside that process before the code is ever emitted.
In practice, this means three things happen at the moment of code generation:
- Security context lives inside the agent. Unlike humans, agents have no attention limit, so you can give them the full vulnerability data, the fix history and the signal on whether a change will break the build.
- Guardrails sit on the agents themselves. An actor that can take destructive action needs bounds, not a report after the fact.
- Everything already shipped gets burned down. Twenty years of shipped software is now an attack surface, and no human team is going to clear it. Remediation has to be autonomous, and it has to be trusted. A fix that might break the build gets queued, not merged. The test is not whether a fix was generated, but whether it ships.
Prevention and remediation are not the same problem. When an agent is already authorized to write the code, asking permission to fix what it just wrote adds friction without adding safety. An agent does not ask before fixing a missing semicolon, and it should not need to ask before fixing a vulnerability it just introduced. Remediation is different: the code may already be running, someone else is accountable for it, and that person has to trust the change before it ships. The principle is to remove the human wherever they add nothing and to earn their trust wherever they remain accountable.
What agentic AppSec actually requires
Agentic AppSec is not a better scanner, nor is it “shift left” with better marketing. It requires three things working together.
- Detection must combine deterministic analysis with frontier intelligence and broad context about how vulnerabilities behave in the real world. Deterministic engines are precise but blind to the new vulnerability classes agents invent, while frontier models find what is new but cannot prove it. Neither is enough on its own; the strength lies in combining them and grounding both in context.
- Remediation must be intelligent. It needs broad context on factors like breakability, so the merge rate is high, and it needs local context so the fix actually fits the code. A remediation agent grounded in historical outcome data can tell whether a change will break the build, and that is what turns a suggestion into something that ships.
- Prevention must shift into the agentic creation loop of the software factories. Without it, you stay in the debt loop of finding and fixing forever, and the backlog becomes the attack surface.
Validation as the final step
There has to be a completely separate judge: something independent of the system that wrote the code and the system that fixed it, which attacks the running software or the pre-prod candidate the way an attacker would, across every layer: the agentic layer, the web layer and the API layer. Some classes of issue, especially authorization flaws, business logic errors and agent-specific behaviors, only show up when you probe a running system like an adversary. In effect, you bring the attacker inside. The loop only closes when something independent proves the result holds, because the generator cannot be the validator.
None of this works if the agent generating the code is also certifying it. A model grading its own homework is not a security program; it is a conflict of interest with a dashboard.
New surfaces that the old model cannot see
Agentic development does not only accelerate the old risks; it also creates new ones. Authorization issues and secrets in code have exploded. Agents pick up packages that turn out to be malware, and they hallucinate package names that do not exist. Attackers register those names first, and the next agent installs the payload, a technique now known as slopsquatting. Agents also pull in packages of poor quality that would never have survived a careful human review.
The agents’ own supply chain is also different. Skills and MCP servers are how agents move from chat to actually doing work, yet three lines of English in a skill can be malware, and intent is hard to judge from the surface. Recent research into the agent skills ecosystem found that roughly a third of skills carried security issues, including prompt injection, credential theft, and confirmed malicious payloads. Toxic flows and poisoned MCP servers are not theoretical; attackers have already demonstrated them.
These are not problems that better tooling will solve. The primary author is no longer always a person you can train, and the tools and context the agent uses can be compromised before a line of code is written.
On the loop vs. in the loop
Shifting into the loop is about prevention inside the software factory, while being on the loop is about the role humans play.
Every AppSec model to date has put a human in the loop, making individual calls, and that model breaks at machine speed. There are not enough people, and the ones who remain often did not write the code they are reviewing. The answer is not to remove humans, but to move them from inside the loop to on the loop: setting the bar, governing the agents, auditing the outcomes and deciding what good looks like and holding the system to it.
This is the redefinition of the AppSec persona and the emergence of the AI Security Engineer. The person who used to chase tickets now designs the loops, sets the policies the agents enforce, reviews the decisions the system made and keeps the independent adversarial layer honest. Judgment moves to the outer loop, while the work inside the loop is done by agents that can operate at the speed of the factories.
Most organizations are not there yet. Outside a handful of AI labs, very few teams run true software factories; most are still writing specs, prompting agents and iterating. Human on the loop is the destination, not today’s reality, and that is exactly why the moment is now. The factories are being assembled today, and the security fabric must go into them before they are finished.
Traditional AppSec, as we know it, is dead. “Shift left” was the right model for its moment, but it no longer holds up on its own. What extends it is not a better tool for humans to operate, but a program that agents run, and humans govern. As agents write our software, agents have to secure it, and humans have to own the bar they are held to.
Learn more about Snyk’s new Evo Agentic AppSec solution here.
