The Gap Between Finding and Fixing
Static analysis has always been good at generating work. It finds vulnerabilities, files alerts, and then hands a backlog to developers who have to interpret each finding and write the fix by hand. Microsoft's answer, now extending to Azure DevOps, is to close that loop with AI. Copilot Autofix, already available in GitHub Advanced Security, entered limited preview for GitHub Advanced Security for Azure DevOps, bringing AI-generated remediation to teams that live in Azure Repos rather than GitHub. GitHub's Mike Hanley, its chief security officer, framed the premise plainly: "Finding vulnerabilities isn't the problem. Fixing them is."
We think that sentence captures why this matters more than a typical tooling update. Security backlogs do not fail because teams cannot detect flaws, they fail because remediation competes with feature work and usually loses. Hanley's other claim is the one worth testing in production: developers using Autofix "were fixing code vulnerabilities more than three times faster than those who do so manually." If that speedup survives contact with real enterprise codebases, it changes the economics of the security backlog, which is where most vulnerability programs quietly drown.
How the Autofix Loop Works
The mechanism reuses the analysis engine rather than bolting on a separate model blind to the code. When a CodeQL scan raises a supported alert, a developer clicks "Generate fix," and the same CodeQL engine that located the vulnerability feeds context to an AI model that proposes a remediation. Microsoft's own description is direct: Autofix "uses the same CodeQL engine that finds a vulnerability to generate an AI-suggested fix for it." The proposed change arrives as a pull request, moves through normal review, and the alert auto-resolves once a post-merge scan confirms the fix has landed.
The detail we find important is that the generated fix is not limited to the flagged line. Where a vulnerability requires coordinated changes across multiple files, Autofix can produce them, because the model reasons about the surrounding application context rather than a single expression. That is the difference between a linter suggestion and a real remediation. It also raises the stakes on review, since a multi-file AI change is harder to eyeball than a one-line patch, which is exactly why Microsoft keeps the pull request inside the existing approval flow.
Coverage: Languages and Vulnerability Classes
The preview is not narrow. Copilot Autofix for Azure DevOps supports C and C++, C#, Go, Java, Kotlin, JavaScript, TypeScript, Python, Ruby, and Swift, which covers the overwhelming majority of enterprise application code. On the vulnerability side it targets high-frequency classes: SQL injection, cross-site scripting, path traversal, hardcoded credentials, and other common weaknesses. These are not exotic bugs, they are the everyday findings that clog security dashboards, and automating even a share of them is where the practical payoff lives.
Availability is still deliberately staged. Microsoft opened a limited private preview in mid-June with a sign-up and a phased rollout over several weeks, so this is early access rather than a generally available feature. We would treat the language and vulnerability coverage as the real signal here. The breadth suggests Microsoft is confident enough in the underlying CodeQL-plus-model approach to point it at the full spread of enterprise stacks, not just a curated subset chosen to make the demo look good.
The Human-in-the-Loop Guardrail
Microsoft is careful, and rightly so, to keep a human in the loop. The company stresses that Autofix recommendations come from a large language model and are not guaranteed to be complete or free from unintended side effects, so every generated pull request runs through the same review, testing, and approval process any other change would. Developers remain responsible for validating the fix. This is not hedging language, it is the correct posture for a tool that writes security-sensitive code automatically and then asks a team to trust it.
The risk this guards against is subtle but real. An AI fix that resolves the reported alert while introducing a new defect, or that satisfies CodeQL without actually closing the underlying weakness, is worse than no fix, because it retires the alert and creates false confidence. Keeping remediation inside the pull-request workflow means the same tests and reviewers that gate ordinary changes also gate AI-generated ones. For engineering leaders, the discipline to resist auto-merging these fixes is the whole ballgame, and Microsoft's framing at least points teams in the right direction.
The Billing Model Tells a Story
The commercial design is quietly revealing. Autofix runs on AI credits priced at one cent each, billed to the linked Azure subscription and tracked through Cost Management. That means every generated fix has a metered, visible cost attached to it, which is a notable shift from treating security tooling as a flat-rate platform feature. It also mirrors a broader pattern we have seen across the industry this year, where AI-assisted capabilities are increasingly sold by consumption rather than by seat.
We read the metering as more than a pricing choice. When each remediation carries a per-unit cost, security teams have to decide which alerts are worth spending on, which subtly reintroduces prioritization into a workflow that AI was supposed to make effortless. That is not necessarily bad, prioritization is healthy, but leaders should model the spend before assuming Autofix makes the backlog free. Fast and cheap are not the same thing, and at scale a penny per fix across thousands of alerts becomes a line item someone will eventually question.
What Engineering Leaders Should Weigh
For enterprises already standardized on Azure DevOps, this closes a real gap. GitHub-hosted teams have had Autofix for a while, and bringing it to Azure Repos means organizations no longer have to migrate source hosting to get AI-assisted remediation inside GitHub Advanced Security. That parity matters, because plenty of large enterprises run Azure DevOps precisely because migrating away from it is expensive and disruptive. Meeting those teams where they already work is the pragmatic move, and it is overdue.
The honest caution is that Autofix speeds up remediation, it does not remove the need for judgment. The three-times-faster figure is compelling, but it depends on reviewers who actually read the diffs and tests that actually catch regressions. Used well, this compresses the window between detection and fix, which is where most exploited vulnerabilities live. Used lazily, as a rubber stamp on machine-written security patches, it manufactures confidence without safety. As with most AI tooling arriving this year, the tool is only as good as the discipline around it.
