GitHub Copilot - Faz Business | فاز الأعمال

What’s Coming Next in Visual Studio: Our Microsoft Build 2026 Announcements

Posted on June 2, 2026 by faz_business

Microsoft Build kicks off today in San Francisco, June 2 and 3. If you cannot make it in person, the sessions are streaming online for free, and I want to walk you through what we are announcing for Visual Studio this week.

One idea tie most of it together. Code is an asset, not just an artifact. The tools around it should help you keep it healthy, correct, and easy to evolve as your codebase grows. Every announcement below is a step toward that.

Agents that participate in the work, not next to it

GitHub Copilot in Visual Studio is moving beyond chat and completions. The direction is agents that can participate more actively in the development lifecycle, helping with debugging, profiling, and testing alongside you.

This is not about replacing the tools you already rely on. It is about connecting them more effectively. The debugger, profiler, and test tools already provide deep insight. Agents help turn that insight into action:

Identify issues faster
Explain what is going on
Suggest concrete fixes
Help validate the results

This matters most if you work in large C# or C++ codebases where the hard problems are not “write this function” but “figure out why this thing is slow under load.” That is the work Visual Studio has always been built for. Agents extend it.

Catching errors before the build starts

This one is small and I think you will notice it daily.

Today, a build can still run even when there are obvious errors already sitting in the Error List. The build runs, you wait, the build fails on something you could have seen up front.

We are changing that flow so Visual Studio checks errors and warnings before the build starts. Simple change. Real time saved. The kind of thing that adds up across a week.

Merge conflicts with less manual work

Merge conflicts are something every developer runs into, and they are rarely a good use of anyone’s time.

We are working on AI-assisted conflict resolution to reduce the manual effort these situations require. The goal is not to auto-merge everything. The goal is to help you understand the conflict, make a sensible decision, and get back to the work you were actually doing.

Modernization that moves your apps forward

This summer, we are bringing new capabilities to GitHub Copilot modernization, the integrated agent experience built into Visual Studio that helps you upgrade your applications to the latest .NET stack.

You can migrate Web Forms applications to Blazor for a modern, component-based web stack. You can add Aspire to existing apps for cloud-ready observability and orchestration. The modernization agent assesses your project, builds a plan, and executes upgrades step by step, helping you improve performance and security without starting from scratch.

If you have been carrying a Web Forms app for years because the rewrite math never penciled out, this is worth a fresh look.

Skills that show up when you need them

One of the harder problems with AI tooling is that the right capability often exists, but it shows up at the wrong moment, or you have to know to ask for it.

We are introducing Microsoft-authored skills that apply automatically based on your project type and the task at hand. Less prompting. Less guesswork. A more helpful experience overall. The right capabilities show up when you need them, without requiring you to already know they exist.

Bring your own key, bring your own model

This is the one I have been waiting to talk about.

Historically, AI integration in Visual Studio has been limited to a small set of sanctioned endpoints. That works for a lot of developers, but it has left real customers behind, including teams whose environments call for different choices.

We are moving toward a BYOK approach, bring your own key or model, so you can use different AI models whether they run locally or in the cloud. That gives you more flexibility around performance, cost, and compliance based on the needs of your environment.

If you have been waiting for Visual Studio to meet your environment instead of asking your environment to bend, this is the announcement to watch.

Built on the GitHub Copilot SDK

Underneath all of this is a more unified foundation. Visual Studio is moving to the GitHub Copilot SDK as the foundation for its AI integration going forward.

This one sits below the surface. You will not see it in a menu. What it means in practice is that we can move faster, stay aligned with the broader ecosystem, and bring new capabilities into Visual Studio sooner. Worth knowing about, even though you will mostly feel it through everything else getting better.

Where this is heading

If there is one way to sum up this roadmap, it is this. We are focused on a set of meaningful improvements that remove friction from the inner loop and make day-to-day development feel better.

Code that compiles by default. Faster feedback before you build. Smarter handling of real-world pain points like merge conflicts. AI that works with your tools, not next to them. Flexibility in how you bring AI into your environment.

All of it is designed to fit how you already use Visual Studio, not force you into a different workflow.

Watch it live at Build this week

If you want to see this work in action, here are the sessions I would put on your schedule. All times in Pacific.

Microsoft Build opening keynote (KEY01) Tuesday, June 2, 9:30 AM to 12:00 PM PT Satya Nadella and Microsoft leaders open the week with how Microsoft is creating new opportunities for developers across our platforms in this era of AI. This is the one that sets the frame for everything else.

GitHub, Copilot, VS Code, and More: Live from San Francisco (LIVE104) Wednesday, June 3, 9:00 AM to 11:00 AM PT The closest thing Build has to a hallway conversation with the engineers shipping the work. Live demos, surprise guests, live coding, straight from the teams. Watch this one live if you can.

GitHub Copilot in Visual Studio: Agents That Debug, Profile, and Test (BRK207) Wednesday, June 3, 4:00 PM to 4:45 PM PT This is the demo-heavy session on the agents work above, with Mads Kristensen and Nik Karpinsky from the Visual Studio team. You will see agents root-cause bugs using live runtime behavior, pinpoint performance bottlenecks, and build test coverage to catch regressions before they ship. If you work in enterprise C#, .NET, or C++, this is the one.

Make GitHub Copilot Work Your Way: Custom Tools, Context and Workflows (LAB502D) Self-paced lab, opens Tuesday, June 2, at 12:00 PM PT Build custom Copilot agents from scratch, create reusable Agent Skills, and connect to external services via MCP. Works across VS Code, Visual Studio, CLI, and Copilot coding agent. Complete it on your own schedule.

The full Build schedule, including everything streaming online for free, is at build.microsoft.com.

If something we announced today changes how you think about your day-to-day in Visual Studio, I want to hear about it.

Plan Before You Build: Introducing the Plan agent in Visual Studio

Posted on May 22, 2026 by faz_business

You ask Copilot to tackle something big, it gets to work, and a dozen file changes later you realize you had a completely different approach in mind. The code isn’t wrong… it just isn’t what you were going for.

Last year, we introduced planning as a feature in Agent mode to help with exactly this. Since then, you’ve told us you wanted more control over when planning happens, the ability to edit plans directly, and a way to save and share them. Your feedback shaped what came next: the new Plan agent.

Instead of jumping straight into implementation, the Plan agent starts with a deeper understanding of what you’re trying to build: asking questions, clarifying your intent, and enabling you to iterate on the plan before making a single change.

How it works

Here’s how it works:

Select the Plan agent and describe what you want to build — Choose Plan from the agent picker in Copilot Chat, then tell Copilot what you’re trying to do. You can be as broad as “add authentication to this app” or as specific as “refactor the payment module to support multiple providers.” The more context you give, the better the plan.

Explore and clarify — Copilot scans your codebase using read-only tools and asks clarifying questions when something is ambiguous. Answer these to help Copilot understand what you’re going for. For straightforward tasks, it moves straight to drafting.

Draft and refine — Copilot creates a detailed implementation plan you can review together. Ask it to rethink an approach, add edge cases, split a step into smaller pieces, or reconsider which files to touch.
Edit the plan directly — Every plan is saved as a markdown file at .copilot/plans/plan-{title}.md. Edit it in your editor, refine it through chat, or share it with your team for review. Copilot picks up your changes and keeps everything in sync.
Implement — When you’re satisfied, click Implement plan to hand it off to Agent mode to build. No code changes happen until you say so. Copilot works through the plan step by step, creating and editing files while you watch the progress in real time.

Try it today

The Plan agent helps you figure out what to build before you start building it. Give it a try on your next feature or refactoring task, and let us know how it goes!

Share your feedback on Developer Community and let us know what’s working, what’s not, and what you’d like to see next!

Agent Skills in Visual Studio: Teach Copilot How Your Team Works

Posted on May 14, 2026 by faz_business

Visual Studio now supports Agent Skills, which are reusable instruction sets that teach Copilot agents how to handle specific tasks like running a build pipeline, generating boilerplate, or following your team’s coding standards. Define a skill once, and the agent applies it automatically whenever it’s relevant.

Creating a skill

You can create a skill directly from within Visual Studio. Click the tools icon in the bottom-right corner of Copilot Chat to open the skills panel, a dedicated view of every discovered skill. Click the + button in the top-right corner of the panel and follow the guided flow: choose a destination (global or solution-level skill), pick a name, and Visual Studio generates a skill template for you to fill in. Copilot Agent mode can then assist you in filling in the template. Currently this flow is only available in the Insiders channel and will be in Release soon.

You can also create a skill manually:

Create a skill directory in your repository (.github/skills/my-skill/) or user profile (~/.copilot/skills/my-skill/).
Add a SKILL.md file following the agentskills.io/specification format.
Optionally include scripts, templates, or examples alongside it.

For example, you could have two skills, github-issues and code-review like this:

.github/
  skills/
    github-issues/
      SKILL.md
      templates/
        bug-report.md
    code-review/
      SKILL.md
      checklist.md

Skills are auto-discovered from these locations:

Solution skills (shared via your solution): .github/skills/, .claude/skills/, .agents/skills/
Global/Personal skills (shared via your user profile and available across solutions): ~/.copilot/skills/, ~/.claude/skills/, ~/.agents/skills/

When a skill activates, it appears in the chat window so you always know what’s being applied.

If you are not sure where to start or what skills to create, please check out awesome-copilot for many great community examples!

Managing skills from the skills panel

In addition to creating new skills, you can also manage your skills easily from the skills panel.

From the panel you can:

Edit — Open any skill’s SKILL.md directly in the editor via the ⋯ menu.
Open file location — Jump to the skill directory on disk.
Search — Filter skills by name or keyword.

The panel also surfaces diagnostics for any skill configuration errors, so you can quickly spot and fix issues.

Skills vs. Custom Instructions: when to use what

You may already be using custom instructions (.github/copilot-instructions.md) to guide your Copilot’s behavior. Custom instructions are great for broad, always-on guidance, such as things like “use tabs, not spaces” or “prefer async/await over callbacks.” They are automatically applied to every interaction you have with Copilot.

Agent Skills are different. Skills are task-specific and dynamically loaded. The model decides when a skill is relevant and applies it only in matching contexts.

	Custom Instructions	Agent Skills
Scope	Always active	Activated per-task
Best for	Coding style, conventions, general preferences	Workflows, templates, multi-step procedures
Structure	Single markdown file	Directory with `SKILL.md` + supporting files
Examples	“Use PascalCase for public methods”	“When creating a GitHub issue, use this template and include severity, repro steps, and environment info”

Use custom instructions for rules that should always apply. Use skills for specialized workflows that only matter in certain contexts. Another way to extend your agent’s capabilities is through MCP tools, which let the agent interact with external services and APIs. Skills and MCP tools complement each other well — a skill can describe how to handle a task while an MCP tool provides the capability to execute it.

Please give Agent Skills a try and share your feedback in the comments or on Developer Community.

Happy coding!

Visual Studio March Update – Build Your Own Custom Agents

Posted on March 31, 2026 by faz_business

This month’s Visual Studio update gives you new ways to customize GitHub Copilot. Custom agents allow you to build specialized Copilot agents tailored to your team’s workflow, backed by the tools and knowledge sources that matter to your project. Alongside that, agent skills bring reusable instruction sets, and a new find_symbol tool gives agents language-aware navigation across your codebase.

Beyond agents, we’re continuing to invest in the diagnostics experience with Copilot-powered profiling directly from Test Explorer and real-time perf tips during debugging. Security gets a boost too, with Copilot now helping you fix NuGet vulnerabilities right from Solution Explorer.

Download Visual Studio 2026 Insiders to try these features today.

Build your own custom agents

Want Copilot to follow your team’s coding standards, run your build pipeline, or query your internal docs? Custom agents make that possible. They’re specialized Copilot agents defined as .agent.md files in your repository, with full access to workspace awareness, code understanding, tools, your preferred model, and MCP connections to external knowledge sources.

Drop an .agent.md file into .github/agents/ in your repo, and it shows up in the agent picker ready to use.

A few things to keep in mind: if you don’t specify a model, the agent uses whatever you’ve selected in the model picker. Tool names can vary across GitHub Copilot platforms, so check the tools available in Visual Studio to make sure your agent works as expected. The awesome-copilot repo has community-contributed agent configurations you can use as starting points.

Use agent skills

Skills are picked up automatically from several locations in your repository (such as .github/skills/) or your user profile (such as ~/.copilot/skills/). Each skill lives in its own directory with a `SKILL.md` file that follows the Agent Skills specification. When a skill is activated, it appears in the chat so you know it’s being applied.

Check out the awesome-copilot repo for community-shared skills, and look for more user-friendly flows for browsing and creating skills inside Visual Studio in upcoming releases.

Find_symbol tool for agent mode

Copilot’s agent mode now has language-aware symbol navigation. The new find_symbol tool lets the agent find all references to symbols across your project and access metadata like type information, declarations, and scope. This means when you ask Copilot to refactor a method or update a parameter across call sites, it can actually see your code’s structure rather than guessing from text.

Enable the tool, and Copilot uses it automatically when answering questions or suggesting code changes. The difference is noticeable: instead of searching for text patterns, the agent navigates your code using language services.

Supported languages include C++, C#, Razor, and TypeScript, plus any language with a supported LSP extension installed. For best results, use AI models that support tool-calling. Learn more at AI model comparison.

Enterprise MCP governance

MCP server usage in Visual Studio now respects allowlist policies set through GitHub. Admins can specify which MCP servers are allowed within their organizations. When an allowlist is configured, only approved servers can be connected. If you try to use an unauthorized server, you’ll see an error explaining the restriction. This helps organizations control which MCP servers process sensitive data and maintain compliance with security policies.

Profile Tests with Copilot

Ever wanted to profile a specific test without wrestling with profiler configuration? There’s now a Profile with Copilot command right in the Test Explorer context menu.

When selected, the Profiling Agent automatically runs the chosen test and analyzes its performance, combining CPU usage and instrumentation data to deliver actionable insights. By default, it uses Instrumentation profiling and is currently supported in .NET. If you need deeper analysis, you can launch the selected test directly from the Copilot chat window and choose additional profiling tools.

Perf tips powered by live profiling

Performance optimization now happens while you debug, not after. As you step through code, Visual Studio shows execution time and performance signals inline for each step. When you spot a slow line, just click the Perf Tip and ask Copilot for optimization suggestions on the spot.

The Profiler Agent captures runtime data during debugging automatically: elapsed time, CPU usage, and memory behavior. Copilot uses this data to pinpoint performance hot spots and suggest targeted fixes. This keeps optimization part of your regular debugging workflow instead of something you tackle later.

Fix vulnerabilities with Copilot

Spotted a NuGet package vulnerability? Copilot can now help you fix it directly from Solution Explorer. When a vulnerability is detected, you’ll see a notification with a Fix with GitHub Copilot link. Click through, and Copilot analyzes the vulnerability, recommends and implements targeted dependency updates that keep your packages secure without disrupting your workflow.

No more manual vulnerability research or hunting down correct package versions. You address security issues right when they’re discovered.

HTML rich copy/cut

Need to paste code into a presentation, an Azure DevOps work item, or a web-based document? Visual Studio now supports HTML clipboard format when cutting or copying code from the editor. Syntax highlighting and formatting carry over when you paste into HTML-based applications. It’s turned on by default. To customize, go to Tools > Options > Text Editor > Advanced where you can toggle Copy rich text on copy/cut and set the max length.

From our entire team, thank you for choosing Visual Studio! For the latest updates, resources, and news, check out the Visual Studio Hub and stay in touch.

Happy coding!

The Visual Studio team

Visual Studio February Update – Visual Studio Blog

Posted on February 25, 2026 by faz_business

This month’s Visual Studio update continues our focus on helping you move faster and stay in flow, with practical improvements across AI assistance, debugging, testing, and modernization. Building on the momentum from January’s editor updates, the February release brings smarter diagnostics and targeted support for real world development scenarios, from WinForms maintenance to C++ modernization.

All of the features highlighted are available in the Visual Studio 2026 Stable Channel as part of the February 2026 feature update (18.3). Please update to the latest version to try out these new features!

WinForms Expert Agent

The WinForms Expert agent provides a focused guide for handling key challenges in WinForms development. It covers several important areas:
Designer vs. regular code: Understand which C# features apply to designer-generated code and business logic.

Modern .NET patterns: Updated for .NET 8-10, including MVVM with Community Toolkit, async/await with proper InvokeAsync overloads, Dark mode with high-DPI support, and nullable reference types.
Layout: Advice on using TableLayoutPanel and FlowLayoutPanel for responsive, cross-device design.
CodeDOM serialization: Rules for property serialization and avoiding common issues with [DefaultValue] and ShouldSerialize*() methods.
Exception handling: Patterns for async event handlers and robust application-level error handling.

The agent serves as an expert reviewer for your WinForms code, providing comprehensive guidance on everything from naming controls to ensuring accessibility. The WinForms Agent is automatically implemented and included in the system prompt when necessary.

Smarter Test Generation with GitHub Copilot

Visual Studio now includes intelligent test generation with GitHub Copilot, making it faster to create and refine unit tests for your C# code. This purpose-built workflow works seamlessly with xUnit, NUnit, and MSTest.

Simply type @Test in GitHub Copilot Chat, describe what you want to test, and Copilot generates the test code for you. Whether you’re starting fresh or improving coverage on existing projects, this feature helps you write tests faster without leaving your workflow.

Slash Commands for Custom Prompts

Invoke your favorite custom prompts faster using slash commands in Copilot Chat. Type / and your custom prompts appear at the top of the list, marked with a bookmark icon for easy identification.

We’ve also added two additional commands:

– /generateInstructions: Automatically generate a copilot-instructions.md file for your repository using project context like coding style and preferences

– /savePrompt: Extract a reusable prompt from your current chat thread and save it for later use via / commands

These shortcuts make it easier to build and reuse your workflow patterns.

C++ App Modernization

GitHub Copilot app modernization for C++ is now available in Public Preview. GitHub Copilot app modernization for C++ helps you update your C++ projects to use the latest versions of MSVC and to resolve upgrade-related issues. You can find our user documentation on Microsoft Learn.

DataTips in IEnumerable Visualizer

You can now use DataTips in the IEnumerable Visualizer while debugging. Just hover over any cell in the grid to see the full object behind that value, the same DataTip experience you’re used to in the editor or Watch window.

When you hover over a cell, a DataTip shows all the object’s properties in one place. This makes it much easier to debug collections with complex or nested data. Whether it’s a List<T> of objects or a dictionary with structured values, one hover lets you quickly inspect everything inside.

Analyze Call Stack with Copilot

You can now Analyze Call Stack with Copilot to help you quickly understand what your app is doing when debugging stops. When you pause execution, you can select Analyze with Copilot in the Call Stack window. Copilot reviews the current stack and explains why the app isn’t progressing whether the thread is waiting on work, looping, or blocked by something.

This makes the call stack more than just a list of frames. It becomes a helpful guide that shows what’s happening in your app so you can move faster toward the real fix.

Profiler agent with Unit Test support

The Profiler Agent (@profiler) now works with unit tests. You can use your existing tests to check performance improvements, making it easier to measure and optimize your code in more situations. The agent can discovers relevant unit tests/BenchmarkDotNet benchmarks that exercise performance-critical code paths.

If no good tests or benchmarks are available, it automatically creates a small measurement setup so you can capture a baseline and compare results after changes. This unit-test-focused approach also makes the Profiler Agent useful for C++ projects, where benchmarks aren’t always practical, but unit tests often already exist.

Faster and More Reliable Razor Hot Reload

Hot Reload for Razor files are now faster and more reliable. By hosting the Razor compiler inside the Roslyn process, edits to .razor files apply more quickly and avoid delays that previously slowed Blazor workflows. We also reduced the number of blocked edits, with more changes now applying without requiring a rebuild, including file renames and several previously unsupported code edits. When a rebuild is still required, Hot Reload can now automatically restart the app instead of ending the debug session, helping you stay in flow.

We are continuing to invest in features that help you understand, test, and improve existing code, not just write new code. Try these updates in the Visual Studio 2026 Stable Channel and let us know what is working well and where we can improve. Your feedback directly shapes what we build next.

Roadmap for AI in Visual Studio (February)

Posted on February 5, 2026 by faz_business

After a busy January (catch up here), we’re shifting focus to reliability and refinement. This month is about tightening core workflows, improving agent stability, and building on the MCP foundations we’ve been laying.

These are active areas of work, not delivery commitments. Upvote the features that matter most to you.

Agent Mode & Coding Agents

Reliability is the priority this month. We’re raising the floor on agent-driven scenarios with:

Planning Agent

First steps toward a dedicated agent for multi-step task planning and execution.

Copilot SDK & Platform Integration (Experimental)

We’re also beginning early work to better integrate the Copilot CLI into Visual Studio Copilot.

Model Context Protocol (MCP)

MCP keeps external tools and services connected to VS in a governed, scalable way. February focus:

Models & Context Management

Under-the-hood work to keep Copilot fast as context grows:

Copilot experience in Editor

Smoother Copilot integration with existing editor behavior:

We’re excited for you to try these improvements as they roll out. As always, feedback is incredibly important—please upvote or comment on the linked Developer Community items so we know what matters most to you.

Thanks for continuing to build with us.

Visual Studio January Update – Visual Studio Blog

Posted on January 28, 2026 by faz_business

Productivity Improvements

This month, we are bringing you a series of small yet long requested and popular features to let you better control and customize your editor.

Fast scrolling: Hold down the Alt key while scrolling the mouse wheel to move quickly when reviewing code or reading documentation. You can adjust the fast-scrolling speed in Tools > Options > Text Editor > Advanced > Touchpad and mouse wheel scrolling sensitivity.
Middle click scroll: Press down on your scroll wheel and move the mouse to quickly scroll through your document, making it easier to explore large files. This feature is off by default in 18.3 Insiders 2 and needs to be enabled via Tools > Options > Text Editor > Advanced > Middle click to scroll.
HTML-rich copy paste: Visual Studio now supports HTML clipboard format when cutting or copying code from the editor. You can paste colorized code into web versions of Office apps, Azure DevOps work items, or other HTML-based controls. This feature is available in the latest Insiders and will be shipped in the Release channel soon.
Syntactic line compression: Lines without letters or numbers are compressed by 25%, letting you see more code at once. Regular lines stay the same height. Enable this feature in Tools > Options > Text Editor > Advanced by checking Compress blank lines and Compress lines that do not have any alphanumeric characters.
Slimmer left margin: We’ve heard you that you would like to see a slimmer left margin to have more horizontal space for your code! To save an extra column, we moved the Quick Actions icon (lightbulb or screwdriver) from the margin into the editor, where it appears inline with your code when fixes or refactoring are available. To try out the experience now, go to Tools > Options > Text Editor > Advanced and check Show Quick Actions icon inside the editor. We also have more customized margin controls coming, so stay tuned!

Colorized Code Completions

Code completions are now colorized with syntax highlighting to help you quickly parse suggested code between variables, functions, and other elements! To try out this experience, go to Tools > Options > Text Editor > Code Completions and check “Use colorized text for code completions.”

To differentiate suggestions from actual code, colorized completions use lower opacity and italic styling. If you want to further customize the look, go to Tools > Options > Environment > Fonts and Colors and select “Code Completions” from the Display items list. From there, you can customize the font, size, foreground/background colors, and styles (bold, italicized…).

Click to Accept Code Completions Partially

Have you ever wanted to accept a code completion partially with a single click? With this new feature, you can click directly inside a suggestion to accept it up to the cursor position. As you hover over the suggestion, each segment highlights to show exactly what will be accepted.

This feature gives you more control over how much of a completion you want to accept. If you prefer using the keyboard, you can still press Ctrl + Right Arrow to accept one word at a time, or Ctrl + Down Arrow to accept one line at a time.

Streamlined Markdown Preview Controls

Visual Studio Markdown editor now gives you faster, clearer access to preview options:

Switch between preview modes: Split Preview shows the editor and preview side by side, Open Preview shows only the preview, and Edit Markdown shows just the editor. The preview-only mode helps you focus on rendered content, especially for large images or complex Mermaid diagrams.
When previewing a Mermaid diagram, use the zoom controls in the top-left corner to zoom in or out for better readability.
When Copilot Chat generates markdown content, click the Preview button at the top right corner of the chat window to see a rendered view. You can then edit and save the content directly. No need to copy and paste manually.

To try all this latest goodness, please update your Visual Studio regularly and join us in the Insiders Channel if you haven’t yet! (Note: All features shared in this blog post are available in Visual Studio 2026 only.) Please give them a try and let us know any feedback you have or the next thing you would like to see!