.NET Development Tasks Covered by the dotnet/skills Repository: A Complete Guide

The dotnet/skills repository encodes expert knowledge for .NET development tasks—including version upgrades, testing analysis, MSBuild orchestration, diagnostics, and AI-assisted coding—through reusable skills defined in SKILL.md files.

The dotnet/skills repository serves as a centralized toolbox of reusable skills for common .NET development tasks. Each skill lives under plugins/<category>/skills/<name>/SKILL.md and is paired with supporting assets, reference documentation, and a plugin.json manifest that declares its capabilities to the validation runtime.

Upgrade and Migration Tasks

The repository provides comprehensive skills for modernizing .NET applications across versions and patterns.

Cross-Version Migration skills handle project upgrades between specific .NET versions. The migrate-dotnet8-to-dotnet9, migrate-dotnet9-to-dotnet10, and migrate-dotnet10-to-dotnet11 skills in plugins/dotnet-upgrade/skills/ automate the transition of project files, dependencies, and breaking changes. Each skill references authoritative migration guides stored in its local references/ folder.

Legacy API Migration addresses deprecated patterns. The thread-abort-migration skill in plugins/dotnet-upgrade/skills/thread-abort-migration/SKILL.md converts Thread.Abort usage to modern cancellation patterns. The migrate-nullable-references skill includes PowerShell scripts such as plugins/dotnet-upgrade/skills/migrate-nullable-references/scripts/Get-NullableReadiness.ps1 to assess Nullable Reference Types readiness.

Testing and Quality Assurance

Testing skills analyze code quality, detect anti-patterns, and facilitate framework migrations.

Test Analysis skills include test-smell-detection which identifies problematic patterns like Thread.Sleep or unawaited tasks in plugins/dotnet-test/skills/test-smell-detection/SKILL.md. The test-gap-analysis skill finds uncovered code paths, while grade-tests calculates CRAP scores and coverage metrics.

Test Migration capabilities support framework transitions. The migrate-xunit-to-xunit-v3 skill in plugins/dotnet-test-migration/skills/migrate-xunit-to-xunit-v3/SKILL.md handles breaking changes between xUnit versions.

Build Orchestration and Package Management

Skills for MSBuild and NuGet streamline complex build scenarios.

MSBuild Tasks include target-authoring for custom targets, resolve-project-references for dependency management, and build-perf-diagnostics for incremental build analysis. These are defined in plugins/dotnet-msbuild/skills/ with implementations that generate binary logs and detect antipatterns.

NuGet Management focuses on centralized dependency control. The convert-to-cpm skill in plugins/dotnet-nuget/skills/convert-to-cpm/SKILL.md migrates solutions to Central Package Management format, resolving version conflicts and enforcing trusted publishing pipelines.

Diagnostics and Performance

Diagnostic skills capture runtime data and benchmark code execution.

Dump and Trace Collection skills wrap diagnostic tools. The dump-collect skill in plugins/dotnet-diag/skills/dump-collect/SKILL.md invokes dotnet-dump for Windows, Linux, and Android core dumps. The dotnet-trace-collect skill orchestrates dotnet-trace sessions.

Performance Testing includes the microbenchmarking skill which configures BenchmarkDotNet runs, located in plugins/dotnet-diag/skills/microbenchmarking/SKILL.md.

Web, Mobile, and AI Development

The repository covers modern application stacks from web UI to AI-assisted workflows.

Blazor Development skills in plugins/dotnet-blazor/skills/ include create-blazor-project for scaffolding, use-js-interop for JavaScript interop, and author-component for reusable component creation. The create-blazor-project skill supports optional authentication and prerendering configuration.

ASP.NET Core tasks include minimal-api-file-upload and dotnet-webapi scaffolding in plugins/dotnet-aspnetcore/skills/. The configuring-opentelemetry-dotnet skill sets up distributed tracing instrumentation.

MAUI Development handles cross-platform UI concerns. Skills like maui-theming, maui-shell-navigation, and lifecycle management reside in plugins/dotnet-maui/skills/.

AI-Assisted Development includes technology-selection for stack decisions and mcp-csharp-create for AI-driven project scaffolding in plugins/dotnet-ai/skills/.

Advanced Language Features

Low-level and specialized tasks appear in plugins/dotnet-advanced/skills/.

The dotnet-pinvoke skill manages platform invocation code, while nuget-trusted-publishing configures secure package publishing pipelines. C# scripting and other advanced scenarios are supported through dedicated skill definitions.

Skill Validation Infrastructure

The eng/skill-validator project provides the runtime that loads and executes skills.

Entry Point: eng/skill-validator/src/Program.cs serves as the main CLI entry point, parsing plugin.json manifests and dispatching to requested skills.

Discovery: eng/skill-validator/src/Shared/PluginDiscovery.cs implements the scanning logic that locates plugin.json files across plugins/<category>/ directories.

CI Validation: The .github/workflows/skill-validator.yml pipeline validates skill definitions, ensuring consistency between manifests, SKILL.md specifications, and reference data.

How to Invoke .NET Development Skills

Skills are executed through the skill-validator CLI. Below are examples for common tasks.

Upgrade a Solution from .NET 8 to .NET 9

dotnet run --project eng/skill-validator/src/SkillValidator.csproj \
    --skill dotnet-upgrade/migrate-dotnet8-to-dotnet9 \
    --input-path /path/to/MySolution.sln \
    --output-path /tmp/MigratedSolution

This command processes the solution file, applies nullable reference type migrations, updates .csproj files, and generates a migration report. Implementation details are in plugins/dotnet-upgrade/skills/migrate-dotnet8-to-dotnet9/SKILL.md.

Detect Test Smells

dotnet run --project eng/skill-validator/src/SkillValidator.csproj \
    --skill dotnet-test/test-smell-detection \
    --input-path /src/MyProject.Tests \
    --output-path /tmp/SmellReport.json

The skill analyzes test code for anti-patterns and outputs a JSON report. See plugins/dotnet-test/skills/test-smell-detection/SKILL.md.

Scaffold a Blazor WebAssembly Project

dotnet run --project eng/skill-validator/src/SkillValidator.csproj \
    --skill dotnet-blazor/create-blazor-project \
    --project-name MyBlazorApp \
    --output-path ./Generated/BlazorApp

This generates a complete Blazor solution with optional authentication modules.

Collect a Linux Core Dump

dotnet run --project eng/skill-validator/src/SkillValidator.csproj \
    --skill dotnet-diag/dump-collect \
    --pid 12345 \
    --output /tmp/dotnet.dump

The underlying script invokes dotnet-dump collect with platform-specific flags.

Summary

• The dotnet/skills repository covers .NET development tasks through discrete, reusable skills stored in plugins/<category>/skills/<name>/SKILL.md.
• Upgrade and migration tasks include cross-version project updates, legacy API conversion, and nullable reference type adoption.
• Testing skills provide smell detection, gap analysis, quality grading, and framework migration support.
• Build and package management skills handle MSBuild target authoring, project reference resolution, and Central Package Management conversion.
• Diagnostic skills integrate dotnet-dump, dotnet-trace, and BenchmarkDotNet for performance analysis.
• Web and mobile development includes Blazor component authoring, ASP.NET Core minimal APIs, and MAUI theming.
• AI-assisted skills enable technology selection and automated project scaffolding.
• Validation infrastructure in eng/skill-validator ensures skill correctness through automated CI pipelines.

Frequently Asked Questions

How do I add a new .NET development task to the repository?

Create a new directory under plugins/<category>/skills/<name>/ containing a SKILL.md file that defines the skill's purpose, inputs, and workflow. Include a references/ folder for documentation and a scripts/ folder for helper executables. Update the plugin.json in the category root to register the new skill. The CI pipeline in .github/workflows/skill-validator.yml automatically validates the definition.

What is the difference between a plugin and a skill in the dotnet/skills repository?

A plugin is a top-level category folder (e.g., plugins/dotnet-upgrade) containing a plugin.json manifest that declares all skills in that domain. A skill is a specific task implemented within that category (e.g., migrate-dotnet8-to-dotnet9) defined by its SKILL.md file and supporting assets. The skill-validator uses PluginDiscovery.cs to map plugins to their constituent skills.

Can I run these skills outside of the skill-validator CLI?

While the eng/skill-validator project provides the primary runtime for skill execution, many skills include standalone helper scripts in their scripts/ directories. For example, plugins/dotnet-upgrade/skills/migrate-nullable-references/scripts/Get-NullableReadiness.ps1 can be executed independently to assess code readiness. However, full skill execution requires the validator to parse the SKILL.md workflow definitions.

Which .NET versions are supported by the upgrade skills?

The repository currently includes explicit migration paths for .NET 8 to 9, 9 to 10, and 10 to 11, with each skill located in plugins/dotnet-upgrade/skills/. Each skill references version-specific breaking changes and modernization patterns. The modular structure allows for easy addition of future version transitions as .NET evolves.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}