For twenty years we built better smoke detectors. Now we are finally building firefighters.
We have gotten incredibly good at finding problems.
Your IDE underlines a vulnerability before you finish typing it. Your CI pipeline fails because a transitive dependency three levels deep has a CVE from 2019. Your inbox gets a Dependabot PR every Tuesday that you will politely ignore until Thursday. GitHub Advanced Security, Snyk, Semgrep, Wiz, Orca, Lacework, the alphabet soup of scanners has turned security into a very high resolution photograph of a burning building.
We know exactly where the fire is. We have a heat map. We have a severity score. We have a CVSS vector that nobody reads.
We just do not put it out.
That is the strange era we are exiting.
The Finding Economy Was Profitable
The last decade of AppSec was built on an unspoken agreement: tools find, humans fix. It was a sensible division of labor when finding was hard. You needed abstract syntax trees, taint analysis, symbolic execution, and a PhD to explain why your Python string concatenation was actually remote code execution.
So we built an entire economy around detection. Dashboards that count vulnerabilities. Leaderboards that shame teams for not triaging fast enough. Compliance frameworks that ask if you know about your bugs, not if you fixed them. The metric of success became mean time to detect, not mean time to remediate.
The result is predictable. The average enterprise has something like 50 to 100 days of open critical vulnerabilities, not because engineers are lazy, but because the funnel is fundamentally broken. You can generate ten thousand findings with a single scan. You cannot generate ten thousand fixes with a single engineer.
Finding scales with compute. Fixing scales with humans. And humans do not scale.
Anyone who has maintained an open source project knows this pain intimately. You get a beautiful, detailed issue report with a proof of concept, a CVSS score, and a polite note that you are endangering the internet. What you do not get is a patch that passes your tests, respects your architecture, and does not break the three weird edge cases only you know about.
We celebrated the finder. We burned out the fixer.
Why Fixing Is a Different Species of Problem
It is tempting to think of fixing as finding plus one more step. It is not. It is a different cognitive task entirely.
Finding is a pattern matching problem. Does this code look like that bad code I have seen before? Is user input flowing into a sensitive sink without sanitization? An LLM is shockingly good at this, because it has seen millions of examples of both good and bad code.
Fixing is a planning and context problem. To fix a bug correctly you need to understand intent, not just syntax. You need to know what the original author was trying to do, what invariants the rest of the codebase relies on, what the test suite actually covers versus what it pretends to cover, and how to make the smallest possible change that closes the hole without opening two new ones.
A bad fix is worse than no fix. A bad fix gives you false confidence and a new CVE with a different name.
This is why early attempts at auto remediation felt like a Clippy for security. "It looks like you have a SQL injection, would you like me to add an ORM?" No, thank you.
What changed is not that models got better at writing code, although they did. What changed is that they got better at operating tools. The new generation is not a chatbot that writes a diff. It is an agent that can reproduce the bug, write a test that fails because of it, edit the source, run the relevant tests, observe the failure, try again, and iterate until the green checkmarks come back.
In other words, it can do the boring, methodical, unglamorous loop that human engineers actually do when they fix something. It just does not get tired at 2 AM.
We Are Entering the Patch Agent Era
Look at what is happening at the edges.
In open source, you now have agents that watch for new CVEs in your dependencies, check if you are actually exploitable, generate a minimal upgrade or patch, run your CI, and open a PR with a proper explanation. Not a version bump. A fix.
In enterprise security, purple teams are using agents to continuously exploit their own apps, then immediately write the guardrail that would have stopped it. The feedback loop that used to take quarters now takes minutes.
And in the lab, researchers are building self healing codebases. Systems where every night, an agent pulls the latest vulnerability feeds, clones your repos, tries to break in, and if it succeeds, patches itself, tests itself, and leaves a commit message that is more thorough than most of your interns. It is not science fiction anymore. It is just engineering that is slightly ahead of adoption.
This is a profound shift in metaphor. We are moving from security as a camera to security as an immune system. A camera records an intruder. An immune system neutralizes it, remembers it, and gets better next time.
The immune system model also understands something the camera model never did: you cannot fix everything. You have to prioritize by exploitability, by blast radius, by whether this service is actually exposed to the internet or buried behind three layers of auth that you swear are there. Agentic fixers are good at that triage, because triage is reasoning, not just ranking.
The Trust Problem Nobody Wants to Talk About
Of course, there is a catch. And the catch is trust.
Will you let an AI push code to main?
Most teams will say no, correctly. The early adopters will have guardrails. Human in the loop approval. Restricted file paths. No changes to auth logic without a human review. Full test runs plus ephemeral preview environments plus semantic diff checks.
But that boundary will move. We already let Dependabot merge patch updates automatically if tests pass. We already let Copilot write 40 percent of our code. At some point, the risk calculus flips. What is riskier: letting an agent patch a well understood path traversal in a well tested utility function, or leaving that path traversal open for 87 days while you wait for a human to find a free afternoon?
We will learn to trust fixers the same way we learned to trust compilers. At first, people inspected the assembly output. Then they stopped, because the compiler made fewer mistakes than they did. We are not there yet for security patches, but we are walking that path.
The teams that win will be the ones who build verification better than they build generation. The fix is not the hard part anymore. Proving the fix is correct, safe, and minimal, that is the product.
Think property based tests that the agent generates alongside the patch. Think formal verification for small critical functions. Think second agent models whose only job is to try to break the first agent's patch. An adversarial system that looks a lot like the immune system again: attackers and defenders coevolving inside your CI.
What This Means for Humans
If AI moves from finding bugs to fixing them, what do humans do?
We do the work we were supposed to be doing all along. We stop acting like very expensive linters and start acting like architects.
Humans will set policy: what is allowed to be auto fixed, what requires review, what risk tolerance we have for different systems. Humans will design systems that are easier to fix, smaller blast radius, better tested, more explicit about invariants. Humans will do the weird, cross system reasoning that agents are still bad at, like realizing that fixing this bug in service A will break an undocumented assumption in service B that finance relies on every quarter end.
And perhaps most importantly, humans will be freed to do proactive security instead of reactive ticket closure. Threat modeling. Secure by design. Actually deleting code instead of endlessly patching it.
The dream was never to have a dashboard with zero findings. The dream was to have systems that do not need a dashboard to stay safe.
We spent twenty years shouting louder about fires. The next ten will be about buildings that do not burn.
I build small, practical tools for this exact future, focused on defense, resilience, and systems that fix themselves.
If you want to play with the ideas from this post:
The $20 SOC: Build a Tiny Defensive Network Monitor is how I think about affordable detection for home labs and small teams.
Build the Blackbox: An Offline AI Field Terminal That Works When Nothing Else Does is my guide to building AI systems that work completely disconnected, which matters a lot when you are patching in hostile environments.
Synthetic Corporation Defense: Purple-Team Your HR Before 500 Fake Employees Do covers the other side of the coin, when the attacker is AI generated too.
And Self-Healing Legion: AI That Finds and Patches Its Own CVEs While You Sleep is the full implementation of what I described here, an agentic legion that hunts and fixes its own vulnerabilities on autopilot.
Top comments (0)