Microsoft has begun externalizing an AI-powered Visual Studio Code extension born from a grassroots hackathon, one designed to attack one of software engineering’s most unloved chores: cleaning up vulnerable Python dependencies. The tool, Python Dependency Remediation, has already been used inside the company to dramatically accelerate what became a multi-hour task, and it’s now available on the Visual Studio Marketplace for any Python developer—with a planned integration into the immensely popular Pylance extension that could push it onto millions of machines.
At Microsoft, Python is not a niche language. The company estimates at least 67,000 employees use it every day across production services, internal tools, automation pipelines, and analytics workloads. Python dependencies have swollen into the third-largest vulnerability surface across the entire organization. “We have strong visibility into these vulnerabilities, with tools that continuously detect and surface risks across our codebases,” the company’s internal IT team, Microsoft Digital, noted in a blog post. “The bad news is that turning those insights into action required a complex remediation process.”
That process rarely starts with a single upgrade. “I upgrade one library, and then I’ve got to upgrade 17 other things, and something else breaks, and now my code is completely different,” said Rich Chiodo, a principal software engineer on the Python and Tools for AI team. The result, as Chintan Sheth, a principal engineering manager for Viva Glint, explained, is that “developers avoid the upgrades because the dependency web is so complex. This means the vulnerabilities accumulate over time and can become a real security risk.”
The Scanner Was Never the Hard Part
Modern security tooling excels at generating alerts. Dependency scanners, software composition analysis platforms, GitHub advisories, and CI hooks flood teams with notifications about known CVEs. The bottleneck has always been the tedious, error-prone work that follows: investigating safe version upgrades, resolving transitive conflicts, rewriting code to match changed APIs, and rerunning test suites—only to discover another cascade of breakage. In an enterprise with thousands of repositories, that bottleneck becomes a compliance crisis.
Microsoft’s insight was not that detection needed improvement; it was that the only scalable fix was to embed remediation directly into the developer’s editor. “The challenge was not detecting vulnerabilities but fixing them,” the team wrote. So they built an extension that fits inside Visual Studio Code, where a large share of Python development already happens. Instead of sending engineers to a separate portal or command-line tool, the extension surfaces vulnerable packages in the requirements file, proposes upgrades, and—crucially—uses AI to adjust any application code that breaks as a result.
One Click, But With Human Review
The extension scans Python dependency files for known CVE exposure. Once issues are found, it can update packages to safer versions, spin up isolated environments to run the project’s tests, and present a diff of the proposed changes. If the user has access to an AI model through Visual Studio Code’s APIs, the tool goes a step further: it inspects test failures and error output, then generates code migrations to repair the breaking API changes. If no model is configured, the extension still performs package updates but skips the AI-assisted code remediations.
“The extension automatically finds the right updates and then fixes the vulnerabilities, so developers don’t need to do the research, the manual upgrades and fixes, run test cases, debugging—all those things that used to take so much time,” said Shiva Krishna Gollapelly, a senior software engineer in Microsoft Digital and the project’s lead developer. “With our solution, it’s just one button click and it does all of that automatically, with the help of AI.”
Yet “one click” shouldn’t be mistaken for “no oversight.” The tool generates a report detailing every change—package versions, vulnerability rationales, test outcomes, and code diffs—so a developer can review before merging. For enterprise security teams, that report is not a garnish; it’s the audit trail that determines whether a remediation is trusted or treated as an AI hallucination. The report also serves as a debugging aid when the automation hits a snag, providing a trail of what was attempted and why.
From Hackathon to Customer Zero
The project started almost casually. During a Microsoft-wide hackathon, Gollapelly’s manager pointed him to the idea, and he teamed up with colleagues to build a prototype and a demo video. “That’s how it started,” he said. The difference between a typical hackathon memento and a shipped product is what came next: Microsoft Digital treated it as a serious internal tool, hardened it against the chaos of a real enterprise codebase, and eventually presented it to Guido van Rossum—the creator of Python, now a Microsoft employee. Van Rossum immediately saw broader potential. “He suggested that we could take this solution to the world, not just to Microsoft,” said Snigdha Bora, a principal group engineering manager for Employee Experience.
Thus began the handoff to the Python and Tools for AI team, which owns Pylance, the default language support extension for Python in VS Code, used by more than 180 million developers. Graham Wheeler, a principal group engineering manager on that team, confirmed that a jumping-off point is being built into the Pylance installation flow. “One of the things we could do was provide a jumping-off point for this extension, so that when users installed Pylance they’d be prompted to also download Python Dependency Remediation,” Wheeler said. “It can help raise awareness, because many users don’t actually do the dependency scanning and updating that they should.”
Where AI Actually Earns Its Keep
AI dependency remediation isn’t just another checkbox on a product manager’s whiteboard. In the messy reality of Python, a package upgrade often means a library has renamed a function, reorganized its imports, changed a method signature, or deprecated a behavior that existing code relied on. Deterministic tools can update a version number, but they can’t infer that old_function() now lives at new_library.submodule.new_function(). An AI coding assistant, operating inside the editor where the code lives, can read the error, look at the original call site, examine the upgraded library’s API surface, and propose the equivalent code. “We’ve upgraded the library with new methods, calls, and structures. Now, let’s make sure everything works, check for errors in the code, etc. That’s the gap we’re bridging with AI,” said Angel Saldivia, a software engineer on the SharePoint product team.
Making that assistance trustworthy at enterprise scale requires guardrails. Microsoft emphasizes that the extension respects whichever AI model the user connects; it doesn’t force a specific cloud service. This design allows organizations with strict data controls to keep code in-house, but it also means administrators must decide which models are allowed, whether prompts leave the tenant, and what telemetry is collected. The security tool shouldn’t become a supply-chain risk of its own.
Beyond Python: A Pattern for the Polyglot Enterprise
The remediation pattern isn’t limited to Python. “This solution can easily be adapted to other libraries, other programming languages,” Gollapelly noted, citing C#, Angular, and React as examples. JavaScript ecosystems with npm, .NET shops wrestling with NuGet transitive hell, and front-end frameworks with frequent breaking changes all share the same structural problem: a vulnerability scanner can tell you what’s wrong, but the distance from alert to safe, tested fix remains punishingly long.
Microsoft’s advantage is that it can dogfood this pattern across its own sprawling codebase—where Python alone touches production services, data pipelines, and internal tools—and then push the proven workflow into VS Code and, by extension, into GitHub. The company already owns pieces of the puzzle (Dependabot, GitHub Advanced Security, Pylance). Tying them together into a guided, AI-assisted remediation workflow could reshape how organizations handle the maintenance debt that quietly accumulates below the application layer.
Security Teams Get Leverage, Not a Free Pass
For security leaders, a tool that turns a scanner finding into a proposed patch is a weapon against the perennial stalemate between vulnerability management programs and engineering backlogs. But automation doesn’t eliminate the need for prioritization. Not every CVE exposes a live attack surface; not every dependency sits in a reachable code path. Organizations that blindly click “fix all” risk trading security debt for stability debt. The goal, as the tool matures, should be to accelerate the most critical remediations while preserving the nuance of risk-based decision-making.
Test coverage also becomes a gating factor. The extension runs whatever test suite the project provides. A small script with no tests might upgrade cleanly but introduce subtle behavioral regressions. A mature service with shallow integration tests could pass the AI-assisted migration only to fail in production. The tool is a force multiplier for existing engineering discipline, not a substitute.
The Bargain Developers Deserve
The developer experience around security has long been lopsided: engineers own the risk but receive tools that mostly generate more work. Python Dependency Remediation attempts to rebalance that by making the secure fix as cheap as the insecure drift. When an engineer can resolve a dependency vulnerability in minutes inside the editor they’re already using, and when the tool produces a trustable diff and a clear report, the security ask becomes far less adversarial.
That shift matters because accumulated maintenance debt isn’t just a risk number; it’s a morale drain. Developers postpone upgrades not because they don’t care, but because they’ve been burned by cascading breakage. AI can reduce the fear by making the first attempt inexpensive and the failure modes less mysterious. “This tool removes a significant burden from our developers,” Bora said. “We are shifting the entire remediation process left, embedding it early in the development workflow.”
The Quiet Revolution
The industry has been saturated with AI narratives that promise autonomous agents and fully generated applications. Microsoft’s Python Dependency Remediation is something quieter: a focused tool that applies AI to a well-defined, high-friction workflow, measures its value concretely, and leaves room for human judgment. It may not dazzle in a keynote, but if it can routinely turn a neglected vulnerability into a reviewed patch before an incident occurs, it will have done more for real-world security than many grander ambitions.
For Windows-heavy shops that have accumulated Python through automation, data work, DevOps scripts, and internal services, the tool lands at the intersection of two urgent priorities: securing the software supply chain and keeping developers productive. The near-term advice is not to wait for AI to solve everything, but to examine your own remediation gap. If your scanners produce more findings than your teams can safely close within normal sprint cycles, your bottleneck is no longer visibility. Solutions like Microsoft’s extension—coupled with thoughtful policy, solid test coverage, and a culture of routine updates—can close that gap without burning out the engineers you rely on.
The real win, after all, isn’t more alerts or fancier dashboards. It’s making the boring, essential work happen reliably, so that teams can spend their time on the problems that truly require a human mind.