The February 2026 Visual Studio update keeps the focus on one thing: helping you ship faster without breaking your flow. It builds on January's editor improvements and adds more practical upgrades across AI help, debugging, testing, and modernization, including real-world scenarios like WinForms maintenance and C++ upgrades.
All features mentioned here are available in the Visual Studio 2026 Stable Channel as part of the February 2026 feature update (18.3).
WinForms Expert Agent
If you still maintain WinForms apps (and plenty of people do), Visual Studio now includes a WinForms Expert Agent designed to act like a specialized reviewer and guide.
It helps with:
• Modern .NET patterns for .NET 8 to 10, including MVVM (Community Toolkit), async/await best practices, InvokeAsync usage, nullable reference types, and dark mode with high-DPI support
• Layout guidance using TableLayoutPanel and FlowLayoutPanel for more responsive UI behavior
• CodeDOM serialization gotchas, including DefaultValue and ShouldSerialize patterns
• More robust exception handling, especially around async event handlers and app-level safety nets
It's meant to reduce the typical WinForms pain points that show up during upgrades or refactors.
Smarter Unit Test Generation with GitHub Copilot
Visual Studio now makes unit test creation quicker with Copilot's built-in test generation workflow. It supports the common test frameworks people actually use: xUnit, NUnit, and MSTest.
How it works is simple: in Copilot Chat, you type @Test, describe what you want tested, and Copilot generates the unit test code. It's useful whether you're starting from zero or trying to improve coverage without losing momentum.
Slash Commands for Reusable Copilot Workflows
Custom prompts get easier to reuse thanks to slash commands in Copilot Chat. Type / and your saved prompts show up right at the top.
Two new commands stand out:
• /savePrompt turns part of your current chat thread into a reusable prompt you can call later
This is basically Visual Studio nudging Copilot from "chat helper" into "repeatable workflow tool."
C++ App Modernization (Public Preview)
Copilot's C++ modernization tooling is now in public preview. The aim is to help bring older C++ projects forward to newer MSVC versions, while also assisting with upgrade-related breakages that tend to happen during toolset jumps.
If you maintain legacy C++ code, this is the kind of feature that can save days of "why does this compile on the old build server but not on my machine?"
Better Debugging: DataTips in IEnumerable Visualizer
Debugging collections gets a nice quality-of-life upgrade. You can now hover inside the IEnumerable Visualizer grid and see DataTips for the full object behind a value, similar to what you're used to in the editor or Watch window.
This is especially helpful for:
• Nested structures
• Dictionaries with structured values
Less clicking around, more quick inspection.
Analyze Call Stack with Copilot
When debugging stops and you're staring at the call stack thinking "okay… why are we stuck," Visual Studio can now pass the call stack to Copilot for an explanation.
From the Call Stack window, you can choose Analyze with Copilot, and it will summarize what's happening, such as:
• A loop that isn't progressing
• A block or deadlock-like situation
It turns the call stack from raw frames into something closer to a guided diagnosis.
Profiler Agent Now Works with Unit Tests
The Profiler Agent (@profiler) can now run against unit tests, which is a big deal if you already have tests that hit performance-critical paths.
It can:
• Create a small measurement setup if no good tests/benchmarks exist
• Make performance checking more practical for C++ projects too, where benchmarks aren't always set up, but unit tests often exist
So instead of profiling being a separate "big effort activity," it becomes something you can tie into normal testing.
Razor Hot Reload Gets Faster and Less Fragile
Razor Hot Reload is now faster and more reliable, mainly because the Razor compiler is hosted inside the Roslyn process. That reduces delays and improves the Blazor edit-run-edit loop.
Other improvements include:
• More changes apply without forcing a rebuild (including some file renames and previously unsupported edits)
• If a rebuild is required, Hot Reload can restart the app automatically instead of killing your debug session
The goal is obvious: fewer interruptions, more time staying in flow.
Final Thoughts
This February update feels aimed at developers dealing with real codebases, not just greenfield demos. Between WinForms guidance, smarter debugging explanations, test generation, performance tooling that plugs into unit tests, and better Razor Hot Reload, Visual Studio is clearly trying to reduce the everyday friction that slows teams down.
Comments