modernization – Sick Gaming

Why a hands-on course?

There’s no better way to learn than by doing. And in this course you’re not just going to read about the GitHub Copilot modernization and some theory, but the course will give you exercises to do it too. (You will need a GitHub Copilot subscription.)

GitHub Copilot modernization works differently from agentic development tools you may have tried before. It does not just rewrite your code behind the scenes and hand you back something you have to reverse-engineer. It produces transparent, editable artifacts that you can read, question, and adjust: an assessment.md, a plan.md, and a tasks.md. Those files become your guide and your source of truth. You review them, you shape them, and only then does the work begin. The agent assists you, but you make the calls.

The four chapters

The course is organized in the same way you’d approach a modernization journey. Each chapter builds on the last, and each one teaches you not just what to do, but why you are doing it.

Chapter 1 – Assessment

You start by pointing the modernization agent at a legacy solution and letting it analyze what is really there. You explore the generated assessment.md to understand the risks, the dependencies, and the level of effort involved, so you begin from facts instead of guesses.

Chapter 2 – Planning

Next you turn those insights into a plan. The agent produces a plan.md with recommended target frameworks, a sequence of upgrade steps, and an effort estimate. You learn how to review it, customize it for your context, and finalize a plan you actually believe in.

Chapter 3 – Upgrade & Execution

This is where the agentic development happens. The agent executes the plan while you track progress in tasks.md, moving the application forward iteratively. You will see it do the heavy lifting while you stay in the driver’s seat and make the decisions that matter.

Chapter 4 – Cloud with Azure

Modernization is not finished until your app is running where it belongs. In the final chapter you publish the modernized application to Azure App Service and look at the next steps for operating and evolving it, so the journey ends with something live, not just something that compiles.

Get started

You can be up and running in just a few minutes.

Make sure you have Visual Studio 2022 (17.10 or later) or Visual Studio 2026 with a GitHub Copilot subscription.

Clone the repository from github.com/microsoft/dotnet-modernization-for-beginners.

Begin with Chapter 0 (Introduction).

Everything you need is in the repo, including step-by-step written instructions and companion videos for each chapter.

We’re not creating this in a vacuum and we want to hear from you. Open some issues to suggest improvements, request new chapters, or report problems. Feel free to submit PRs if you want too! And don’t forget to star the repo if you find it useful!

Legacy code does not have to be overwhelming. Grab the repo, open Visual Studio, and let us modernize .NET together, one application at a time.

Modernizing a .NET application is rarely a single step. It requires understanding the current state of the codebase, evaluating dependencies, identifying potential breaking changes, and sequencing updates carefully.

Until recently, GitHub Copilot modernization for .NET ran primarily inside Visual Studio. That worked well for teams standardized on the IDE, but many teams build elsewhere. Some use VS Code. Some work directly from the terminal. Much of the coordination happens on GitHub, not in a single developer’s local environment.

The modernize-dotnet custom agent changes that. The same modernization workflow can now run across Visual Studio, VS Code, GitHub Copilot CLI, and GitHub. The intelligence behind the experience remains the same. What’s new is where it can run. You can modernize in the environment you already use instead of rerouting your workflow just to perform an upgrade.

The modernize-dotnet agent builds on the broader GitHub Copilot modernization platform, which follows an assess → plan → execute model. Workload-specific agents such as modernize-dotnet, modernize-java, and modernize-azure-dotnet guide applications toward their modernization goals, working together across code upgrades and cloud migration scenarios.

What the agent produces

Every modernization run generates three explicit artifacts in your repository: an assessment that surfaces scope and potential blockers, a proposed upgrade plan that sequences the work, and a set of upgrade tasks that apply the required code transformations.

Because these artifacts live alongside your code, teams can review, version, discuss, and modify them before execution begins. Instead of a one-shot upgrade attempt, modernization becomes traceable and deliberate.

GitHub Copilot CLI

For terminal-first engineers, GitHub Copilot CLI provides a natural entry point.

You can assess a repository, generate an upgrade plan, and run the upgrade without leaving the shell.

Add the marketplace: /plugin marketplace add dotnet/modernize-dotnet
Install the plugin: /plugin install modernize-dotnet@modernize-dotnet-plugins
Select the agent: /agent to select modernize-dotnet
Then prompt the agent, for example: upgrade my solution to a new version of .NET

The agent generates the assessment, upgrade plan, and upgrade tasks directly in the repository. You can review scope, validate sequencing, and approve transformations before execution. Once approved, the agent automatically executes the upgrade tasks directly from the CLI.

GitHub

On GitHub, the agent can be invoked directly within a repository. The generated artifacts live alongside your code, shifting modernization from a local exercise to a collaborative proposal. Instead of summarizing findings in meetings, teams review the plan and tasks where they already review code. Learn how to add custom coding agents to your repo, then add the modernize-dotnet agent by following the README in the modernize-dotnet repository.

VS Code

If you use VS Code, install the GitHub Copilot modernization extension and select modernize-dotnet from the Agent picker in Copilot Chat. Then prompt the agent with the upgrade you want to perform, for example: upgrade my project to .NET 10.

Visual Studio

If Visual Studio is your primary IDE, the structured modernization workflow remains fully integrated.

Right-click your solution or project in Solution Explorer and select the Modernize action to perform an upgrade.

Supported workloads

GitHub Copilot modernization supports upgrades across common .NET project types, including ASP.NET Core (MVC, Razor Pages, Web API), Blazor, Azure Functions, WPF, class libraries, and console applications.

Migration from .NET Framework to modern .NET is also supported for application types such as ASP.NET (MVC, Web API), Windows Forms, WPF, and Azure Functions, with Web Forms support coming soon.

The CLI and VS Code experiences are cross-platform. However, migrations from .NET Framework require Windows.

Custom skills

Skills are a standard part of GitHub Copilot’s agentic platform. They let teams define reusable, opinionated behaviors that agents apply consistently across workflows.

The modernize-dotnet agent supports custom skills, allowing organizations to encode internal frameworks, migration patterns, or architectural standards directly into the modernization workflow. Any skills added to the repository are automatically applied when the agent performs an upgrade.

You can learn more about how skills work and how to create them in the Copilot skills documentation.

Give it a try

Run the modernize-dotnet agent on a repository you’re planning to upgrade and explore the modernization workflow in the environment you already use.

If you try it, we’d love to hear how it goes. Share feedback or report issues in the modernize-dotnet repository.

Tag: modernization

Announcing .NET Modernization for Beginners