“Copilot Autofix turns long lists of vulnerabilities into fixes without requiring 10,000 engineer hours.”
Redeployed is a weekly newsletter that breaks down one important AI story at a time for product builders and engineering leaders. Every issue explores what the shift means for technology companies and how leaders can respond.
GitHub made Agentic Autofix generally available. A company can now assign a code scanning alert to Copilot much as it would assign the issue to a developer.
The agent explores the relevant files, proposes a fix, reruns CodeQL to check whether the alert has been resolved, and iterates before opening a draft pull request for review. Teams can also group as many as 25 alerts into one assignment and receive a single remediation PR. That distinction matters.
Copilot Autofix already helped developers understand individual findings and apply proposed patches. Agentic Autofix takes responsibility for a larger unit of work: investigate the problem, modify the codebase, verify the result, and prepare the handoff.
Security remediation is becoming delegable work.
The Fix Is Now a Workflow
Security tools have historically been better at finding problems than getting them fixed.
A scanner produces an alert. A security engineer assesses its severity. The issue enters a backlog. A developer reconstructs the relevant context, creates a patch, runs tests, and submits the change for review. Each handoff introduces delay, particularly when the affected code is old or owned by a team with more urgent product work.
Agentic Autofix compresses several of those steps into one session. It can look beyond the affected file, make coordinated changes, rerun the CodeQL query, and explain what it changed in the resulting pull request.
The work still starts with a finding and ends with human review. What changes is everything between those points.
That could materially alter the economics of security debt. Old findings have always competed with roadmap work for engineering time. Once the marginal cost of investigating and preparing a fix falls, a larger share of the backlog becomes practical to address.
GitHub has already seen this direction with its earlier Autofix tooling. In 2025, the company says more than 460,000 security alerts were fixed using Copilot Autofix, with average remediation time falling from 1.29 hours to 0.66 hours.
Those are GitHub-reported figures, and the new agentic workflow goes further than the suggestion-based product measured during that period. Still, the data shows why automated remediation is becoming part of the platform rather than a separate experiment.
Review Capacity Becomes the Constraint
GitHub is explicit that Agentic Autofix works on a best-effort basis. Its documentation tells users to review and test every proposed change before merging it.
The validation boundary is also narrower than the headline may suggest. The agent can confirm fixes by rerunning the applicable CodeQL query suite, but it cannot validate alerts produced by custom CodeQL queries, the security-extended suite, or third-party scanners. It currently handles backlog alerts on the repository’s default branch.
Passing the scanner therefore means the detected condition is gone. It does not prove the change preserves every product behavior, respects undocumented architectural constraints, or introduces no new risk elsewhere.
If agents begin creating remediation pull requests faster than teams can examine them, the backlog has only changed form. The open alerts disappear while an approval queue takes their place.
Review capacity is now part of the deployment decision. Leaders need to decide which alert classes are suitable for agentic remediation, which repositories require specialist review, and what evidence must accompany a change before it can be merged.
AMD Shows Where This Can Lead
GitHub’s customer reporting on AMD provides a concrete example of the broader trajectory.
AMD uses Copilot Autofix in what the company calls a “historical agent,” an automated workflow that searches legacy code for dormant vulnerabilities and proposes patches. GitHub says AMD now resolves approximately 70 percent of vulnerability classes automatically through that workflow.
AMD is also tracking the maintainability of AI-generated code instead of relying only on the number of fixes produced.
The useful lesson is the operating model around the agent.
AMD gave the system a bounded problem, connected it to an existing detection and remediation process, and paired automation with a quality measure. The agent was not asked to improve security in the abstract. It received a defined class of work with an observable result.
That is a better starting point for most engineering teams than broad autonomy.
What Leaders Should Do Now
Start with a narrow repository group and one or two well-understood alert classes. Avoid turning on organization-wide remediation before establishing how reviews, failures, and exceptions will be handled.
Measure completed outcomes. Useful metrics include time to an accepted fix, reviewer minutes per PR, reopened alerts, regressions introduced, and cost per accepted remediation. Counting generated pull requests rewards activity without showing whether risk actually fell.
Set an explicit review owner. A security engineer may define the policy and prioritize findings, while the code owner confirms behavior and maintainability. Leaving that responsibility implicit will create another queue.
Track the full cost. Every Agentic Autofix session consumes Code Security AI Credits and GitHub Actions minutes. GitHub supports dedicated budgets for those credits, including hard limits that prevent new sessions from starting after the budget is exhausted.
For talent acquisition leaders, founders, and engineering hiring managers, the staffing implication is also becoming clearer. Teams still need security expertise, but more of its value will sit in prioritization, policy design, exception handling, and review.
The strongest engineers will increasingly be the people who can define the boundaries of automated work and judge whether the result belongs in production.
This issue of Redeployed is brought to you by Tecla Labs: If your team is giving AI agents responsibility for real engineering work, the difficult part is defining what they should own, how their work will be evaluated, and where human judgment must remain in the loop. Tecla Labs maps the workflow, identifies where an agent can create measurable value, and defines the evaluations and human gates required for production.
The Decision Ahead
I would begin with one repository, one category of alert, and a named reviewer. Then I would compare the complete workflow against the current manual process, including review time and failures.
If the agent reduces verified security debt without increasing regressions or exhausting review capacity, expand its responsibility. If it only produces more pull requests, the workflow still needs work.
The leadership decision is now specific: which security outcomes are ready to be assigned to an agent, and who owns the evidence required to accept its work?
Connect With Other Technology Leaders
If you want to exchange practical ideas with senior technology and product leaders navigating the AI era, check out the upcoming GILD Forums. They bring together experienced operators for peer discussions around the technology and business decisions they are working through right now.
More to come…
– Gino Ferrand, Founder @ Tecla Labs