Visual Studio’s Plan Agent Is the Design Review AI Coding Needed
The most honest feature in Microsoft’s Visual Studio May update is not another code-generating trick. It is the Plan agent, which effectively admits what senior engineers have been saying since the first impressive-but-chaotic AI diff hit a pull request: agentic coding needs a design review before it needs an implementation.
That sounds obvious until you look at how most coding-agent workflows still behave. A developer writes a prompt. The agent rummages through the repository. A few minutes later, the team is staring at a multi-file diff that may be brilliant, subtly wrong, or both. The review then has to reconstruct intent from artifacts. Why did it touch this interface? Why did it choose this migration shape? Why did it delete that helper? Why is the test update hiding the behavior change? This is not code review. It is archaeology with syntax highlighting.
Visual Studio’s May update adds a Plan agent, an Agent Skills panel, context-window usage visibility, and multi-file summary diffs for Copilot and normal Git changes. None of these are keynote features in the “watch AI build an app” sense. Good. They are better than that. They are review ergonomics for the world where AI writes enough code that the bottleneck becomes understanding, constraining, and safely accepting it.
The Plan agent appears as Plan in the Copilot Chat agent picker. Microsoft says it uses read-only tools to explore the codebase, asks clarifying questions when needed, drafts an implementation plan, and makes no code changes until the user explicitly chooses to implement. Plans are saved as markdown files under .copilot/plans/plan-{title}.md. Developers can edit them directly, refine them through chat, share them with teammates, and then click Implement plan to hand execution to Agent mode.
That file path matters more than it looks.
A plan in the repo beats a plan trapped in chat
Saving the plan as markdown turns “the agent thought about it” into an artifact. Artifacts can be reviewed. They can be diffed, commented on, linked from issues, attached to pull requests, revised by teammates, and reused as context later. Chat history is a foggy place to store architecture decisions. A file is a contract the team can inspect.
This is especially important for medium- and high-risk work: auth changes, data model migrations, concurrency fixes, public APIs, multi-service refactors, security-sensitive code, and anything where the phrase “just let the agent try” should trigger a small alarm. Requiring a plan before implementation is not process theater. It is the cheapest point to catch a wrong assumption. Once an agent has produced a 27-file diff, rejecting the design feels expensive, so teams become tempted to patch around it. That is how bad architecture gets merged one plausible chunk at a time.
The Plan agent also changes the accountability shape. A human can approve, reject, or edit the plan before any code moves. That keeps the author in the loop at the intent layer, not merely at the diff layer. The agent may execute, but the engineer still owns the approach. That distinction is not philosophical. It is how teams keep responsibility from dissolving into “Copilot did it.”
Microsoft’s standalone Plan-agent post says the feature was shaped by feedback asking for more control over when planning happens, direct plan editing, and a way to save and share plans. That feedback tracks with real team pain. Developers do not just need faster code generation. They need a way to slow generation down at the moments where thought is cheaper than cleanup.
Generated code needs a better review surface
The second important piece is Visual Studio’s multi-file summary diff. After Copilot edits, developers get one tab showing all changed files and diffs, with accept and undo controls across all files, per file, or per diff chunk. Microsoft is also bringing the same multi-file summary diff experience beyond Copilot into Git Changes, Git branch history commit details, and pull request lists in the Git Repository window, with some PR-list support currently tied to Visual Studio Insiders and a preview feature.
This is exactly the kind of mundane UI work AI coding needs. Agentic edits tend to spread. A prompt that begins as “add validation” becomes a helper change, a model update, a test adjustment, a message tweak, and a migration. Traditional file-by-file review makes it easy to miss the actual risk, which often lives between files: an interface changed in one place, assumptions changed in another, tests updated to match the new behavior, and suddenly the system is different in a way no single file explains.
A unified summary diff lets the reviewer first inspect scope. How many files changed? Which layers? Did the agent touch tests, production code, configuration, generated files, and docs all at once? Are there chunks that can be accepted independently? Should the whole thing be rejected before anyone spends thirty minutes reading indentation? That top-down pass is not laziness. It is triage.
The new context-window indicator is similarly small and useful. It shows how much conversation, file, and model context has been consumed, changing based on the selected model and current conversation. Context failure is one of the more annoying agent failure modes because it rarely announces itself cleanly. The output just gets vaguer, repeats old assumptions, forgets constraints, or stops respecting earlier decisions. Making context saturation visible gives developers a chance to split the task, summarize, or restart before quality degrades.
The Agent Skills panel rounds out the governance story. Visual Studio can discover skills from workspace and user profile locations and lets users edit or open them from the chat UI. Skills are becoming reusable behavior packages: how the repo builds, how tests are written, how migrations are reviewed, how deployment works. If those instructions live in hidden files nobody can find, they become configuration drift with a friendlier name. Surfacing them in the IDE nudges teams to treat agent behavior like project configuration, which means ownership, review, and eventually security scanning.
There is plenty else in the May update — commit-message custom instructions moving into repository Copilot custom-instruction files, MSVC Build Tools v14.51 with C++23 conformance work, consteval and coroutine improvements, sample-based PGO, preview Intel APX support, ARM SVE work, <flat_map>, <flat_set>, and a <regex> overhaul. But the agentic-coding story is the coherent one: plan first, expose context, manage skills, review multi-file changes as a shape before accepting details.
For teams using Copilot seriously, the operating model should be explicit. Require Plan for tasks above a defined risk threshold. Review the generated .copilot/plans markdown like a mini RFC. Add non-goals before implementation: do not change public API, do not broaden permissions, do not touch migrations, preserve behavior, add regression tests. After Agent mode runs, start with the multi-file summary diff, scan the scope, inspect risky chunks first, and accept in pieces. If the agent changed more than the plan justified, reject or re-plan.
This update is Microsoft quietly agreeing with the critique of vibe coding. The problem is not that agents write code. The problem is that they can skip the human checkpoints that make code safe to merge. Visual Studio is adding those checkpoints back into the workflow. Not glamorous. Correct.
Sources: Visual Studio Blog, Visual Studio Plan Agent announcement, GitHub Docs