Dotnet Skills: The Official Microsoft Repository for AI Coding Agents

The Expertise Gap: Why Generic AI Struggles with .NET

Modern .NET development is powerful but complex. Between deep MSBuild hierarchies, intricate NuGet dependency trees, and the nuances of Entity Framework performance, general-purpose Large Language Models (LLMs) often hit a wall. They can write a basic C# class, but they struggle to diagnose why a build is failing in CI or how to safely upgrade a legacy project to .NET 11.

dotnet/skills is the Microsoft .NET team's answer to this expertise gap. It's a curated set of core skills and custom agents designed to turn your AI assistant into a senior .NET engineer.

Built on the agentskills.io open standard, these tools extend the capabilities of Claude Code, Cursor, and Copilot CLI with domain-specific knowledge and workflows. The standard ensures that skills are portable, verifiable, and structured—consisting of SKILL.md (instructions), templates/ (scaffolding), and references/ (documentation).

2.3k+ stars | 184 forks | 50+ contributors | Standard: agentskills.io

📦 GitHub: dotnet/skills

Quick Reference: dotnet/skills at a Glance

The Plugin Ecosystem: Specialized Skills for Every Task

The repository is organized into several specialized plugins, each targeting a specific area of the .NET ecosystem. Understanding which plugin to use for which task is crucial for maximizing the effectiveness of your AI assistant.

Core Development & Infrastructure

dotnet

The base collection provides fundamental .NET operations that span across the entire ecosystem. This includes common tasks like creating new projects, managing solutions, running applications, and understanding the .NET CLI commands. Think of this as your general-purpose .NET toolkit that every developer needs, regardless of their specialization.

The core skills handle scenarios like:

• Setting up new console, web, or library projects with the correct templates
• Managing solution files and project references
• Understanding and troubleshooting runtime errors
• Working with configuration files and environment variables
• Handling common package restore issues

dotnet-msbuild

MSBuild is the heart of .NET compilation, but its complexity can be overwhelming. Build failures often cascade through multiple layers of dependencies, making root cause analysis difficult. The dotnet-msbuild skill provides comprehensive MSBuild skills for failure diagnosis, performance optimization, and code quality.

Key capabilities include:

• Binary Log Analysis: Integrates with AITools.BinlogMcp to analyze .binlog files, identifying silent failures that don't surface in console output
• Diagnostic Command Generation: Automatically suggests the right diagnostic flags (/verbosity:detailed, /bl, /fileLogger) for different failure scenarios
• Performance Profiling: Identifies bottlenecks in your build process, such as slow tasks, redundant file copies, or inefficient target ordering
• Target Flow Analysis: Visualizes the dependency graph between MSBuild targets, helping you understand why certain tasks execute in a specific order
• Custom Task Debugging: Assists in diagnosing issues with custom MSBuild tasks and inline tasks

Real-world example: When a build fails with "Could not copy assembly X to output directory," the skill can analyze the binlog to determine whether it's a file lock, permission issue, or a race condition in parallel builds.

dotnet-nuget

NuGet dependency management becomes exponentially more complex as your project grows. The dotnet-nuget skill automates package management, dependency resolution, and modernization workflows.

Core features include:

• Vulnerability Remediation: Automatically identifies and resolves transitively vulnerable packages without breaking your dependency graph
• Version Conflict Resolution: Diagnoses and suggests solutions for version conflicts, including PackageReference vs. packages.config migrations
• Package Modernization: Identifies outdated packages and suggests upgrade paths with breaking change warnings
• Source Management: Helps configure private NuGet feeds, authenticated sources, and package caching strategies
• License Compliance: Scans your dependency tree for license conflicts or incompatible licenses

The skill understands complex scenarios like diamond dependencies, where multiple packages depend on different versions of the same underlying library.

dotnet-template-engine

Consistency across team codebases is crucial for maintainability. The template engine skill handles discovery, project scaffolding, and template authoring for consistent team standards.

Capabilities include:

• Custom Template Creation: Guides you through authoring .template.config/template.json files with parameters, symbols, and post-actions
• Template Discovery: Searches local and remote template sources, including private company repositories
• Parameter Validation: Helps design templates with strong validation rules and clear user prompts
• Template Testing: Assists in writing tests for your custom templates using the Template Verification framework
• Template Publishing: Guides the process of packaging and publishing templates to NuGet for team-wide distribution

This is particularly valuable for large organizations that need standardized project structures with pre-configured CI/CD, code style rules, and architectural patterns.

Modernization & Diagnostics

dotnet-upgrade

Migration is one of the most risky operations in software development. The dotnet-upgrade skill specializes in migrating projects across framework versions, handling the migration of csproj properties and API deprecations automatically.

Advanced migration features:

• Multi-Stage Migration Planning: For projects jumping multiple versions (e.g., .NET Framework 4.8 to .NET 8), it creates a staged migration plan with intermediate checkpoints
• API Surface Analysis: Scans your codebase for deprecated APIs and suggests modern alternatives, complete with code transformation examples
• Configuration Translation: Migrates web.config to appsettings.json, handling complex transformation rules and environment-specific settings
• Assembly Binding Redirects: Resolves and removes binding redirects that are no longer necessary in .NET Core/5+
• Platform-Specific Code: Identifies Windows-specific APIs and suggests cross-platform alternatives or platform guards
• Third-Party Compatibility: Checks if your current dependencies have versions compatible with the target framework

The skill can handle complex scenarios like migrating ASP.NET MVC 5 applications to ASP.NET Core 8, including the transition from System.Web dependencies to Microsoft.AspNetCore packages.

dotnet-diag

Production issues require real-time investigation without the luxury of reproducing bugs in a development environment. The dotnet-diag skill integrates with diagnostic tools for performance investigations.

Key diagnostic capabilities:

• Real-Time Counters: Uses dotnet-counters to monitor CPU usage, memory consumption, GC pressure, and ThreadPool statistics during live incident response
• Trace Collection: Guides the collection of ETW traces with dotnet-trace for CPU profiling, allocation tracking, and contention analysis
• Memory Dump Analysis: Assists in collecting and analyzing memory dumps using dotnet-dump, identifying memory leaks and object retention patterns
• EventPipe Integration: Leverages EventPipe for low-overhead production monitoring
• Distributed Tracing: Helps configure and interpret distributed traces in microservice architectures
• Performance Counters: Sets up custom performance counters and EventSource instrumentation

Example scenario: During a production incident with high CPU usage, the skill can guide you through capturing a CPU trace, converting it to speedscope format, and identifying the hot paths in your code—all without restarting the application.

dotnet-test

Testing is fundamental to quality, but test failures can be cryptic. The dotnet-test skill handles running, diagnosing, and migrating .NET tests (MSTest, xUnit, NUnit) with support for localized test failures.

Testing expertise includes:

• Test Discovery Issues: Diagnoses why tests aren't being discovered by the test runner, including common issues with test class visibility, TestSDK versioning, and adapter configuration
• Flaky Test Detection: Identifies tests with non-deterministic behavior, suggesting patterns like time-based dependencies or shared state
• Test Migration: Migrates test projects across frameworks (e.g., MSTest v1 to v2, or MSTest to xUnit) with attribute and assertion transformations
• Code Coverage Analysis: Configures and interprets code coverage reports from Coverlet, helping you understand untested paths
• Test Parallelization: Optimizes test execution strategies, including collection fixtures in xUnit and assembly-level parallelization settings
• Integration Test Patterns: Guides the setup of WebApplicationFactory for ASP.NET Core integration tests, including database seeding and authentication mocking

The skill understands framework-specific idioms, like xUnit's constructor-based setup vs. MSTest's TestInitialize attributes, and can explain the trade-offs.

Specialized Frameworks

dotnet-aspnet

Web development with ASP.NET Core encompasses a vast API surface. The dotnet-aspnet skill provides expertise in web development patterns, middleware, real-time communication, and API patterns.

Web-specific capabilities:

• Middleware Pipeline Design: Guides the creation and ordering of middleware components, explaining the importance of sequence (authentication before authorization, exception handling at the top, etc.)
• Minimal APIs vs. Controllers: Helps you choose between minimal API and controller-based approaches, with migration paths in both directions
• SignalR Real-Time Communication: Assists in setting up hubs, managing connection lifetimes, and scaling with Redis backplane
• Authentication & Authorization: Configures JWT bearer tokens, cookie authentication, OAuth/OIDC flows, and policy-based authorization
• Performance Optimization: Implements response caching, output caching (new in .NET 7+), compression, and HTTP/2 push strategies
• API Versioning: Sets up URL-based, header-based, or query string-based API versioning with proper OpenAPI/Swagger support
• Health Checks: Implements comprehensive health check endpoints for database connectivity, external service availability, and custom business logic

Example: When setting up a new API, the skill can scaffold a complete authentication solution with JWT tokens, refresh tokens, role-based authorization policies, and Swagger UI integration in minutes.

dotnet-data

Data access is often the performance bottleneck in applications. The dotnet-data skill specializes in Entity Framework and data access patterns, including query optimization.

Data access expertise:

• EF Core Migration Management: Creates, reviews, and safely applies migrations, including data seeding and custom SQL scripts
• Query Performance Tuning: Identifies N+1 query problems, suggests eager loading (Include) vs. explicit loading strategies, and explains when to use split queries
• Index Strategy: Recommends database indexes based on your LINQ queries and entity configurations
• Change Tracking: Explains EF Core's change tracking behavior and when to use AsNoTracking() for read-only scenarios
• Concurrency Handling: Implements optimistic concurrency with row versions or [ConcurrencyCheck] attributes
• Raw SQL & Stored Procedures: Guides the use of FromSqlRaw, output parameters, and TVP (table-valued parameters)
• Dapper Integration: Shows when and how to mix EF Core with Dapper for read-heavy scenarios or complex queries that EF Core translates inefficiently

The skill can analyze your DbContext and suggest improvements like compiled queries for frequently-executed patterns or query filters for soft deletes.

dotnet-maui

Cross-platform mobile development has unique challenges. The dotnet-maui skill handles environment setup, diagnostics, and troubleshooting for .NET MAUI.

MAUI-specific support:

• Platform-Specific Setup: Guides installation of Android SDKs, iOS provisioning profiles, and Windows App SDK requirements
• Control Rendering Issues: Diagnoses why controls don't render correctly on specific platforms, often caused by platform differences in layout systems
• Native Interop: Helps implement platform-specific code using dependency injection and platform abstractions
• XAML Compilation Errors: Resolves complex XAML parsing errors, namespace issues, and data binding failures
• Hot Reload Troubleshooting: Fixes issues where XAML Hot Reload stops working or fails to apply changes
• Deployment & Publishing: Guides the process of signing apps, creating release builds, and publishing to app stores
• Shell Navigation: Implements and troubleshoots Shell-based navigation patterns, including query parameters and navigation guards

dotnet-ai

AI/ML capabilities in .NET are expanding rapidly. The dotnet-ai skill covers AI/ML technology selection, RAG (Retrieval-Augmented Generation) pipelines, and MCP (Model Context Protocol) integration.

AI integration capabilities:

• ML.NET Model Training: Guides training classification, regression, and recommendation models with ML.NET
• Model Deployment: Deploys ONNX models and TensorFlow models in .NET applications
• Semantic Kernel Integration: Implements LLM-powered features using Microsoft Semantic Kernel, including prompt engineering and plugin development
• Vector Search: Integrates vector databases like Pinecone, Qdrant, or Azure Cognitive Search for similarity search
• RAG Pipeline Design: Builds complete RAG systems with document chunking, embedding generation, and context retrieval
• MCP Server Development: Creates Model Context Protocol servers that expose .NET business logic to AI agents
• LangChain.NET: Uses LangChain abstractions for agent workflows, memory management, and chain composition

This is the skill that helps you turn a traditional .NET application into an AI-native application with conversational interfaces and intelligent automation.

dotnet11

As .NET evolves, early adopters need guidance on preview features. The dotnet11 skill provides support for the latest .NET 11 APIs and language features as they are released in preview.

Cutting-edge features:

• New C# Language Features: Explains and demonstrates new language syntax, compiler warnings, and semantic changes
• Runtime Improvements: Leverages new runtime optimizations, GC enhancements, and JIT compiler improvements
• BCL Additions: Uses new Base Class Library APIs, often with simpler or more performant alternatives to existing patterns
• Breaking Changes: Identifies breaking changes from .NET 10 and provides migration guidance
• Preview Feature Flags: Helps enable and test preview features safely in isolated environments

Since .NET 11 is in preview as of May 2026, this skill is particularly valuable for teams that want to prepare their codebases for the upcoming LTS release.

How to Install Dotnet Skills

Depending on your preferred AI agent, the installation process varies slightly. Here's a comprehensive guide for all supported platforms.

1. Copilot CLI / Claude Code

These tools use a standardized plugin marketplace flow.

# 1. Add the marketplace
/plugin marketplace add dotnet/skills

# 2. Install a specific plugin (e.g., MSBuild diagnosis)
/plugin install dotnet-msbuild@dotnet-agent-skills

# 3. List available skills to verify
/skills

You can also install multiple plugins in one command:

/plugin install dotnet-msbuild dotnet-nuget dotnet-upgrade@dotnet-agent-skills

To update installed plugins:

/plugin update dotnet-msbuild@dotnet-agent-skills

2. Cursor & OpenCode

Cursor and OpenCode treat the repository as a plugin marketplace or use auto-discovery via .cursor-plugin/ and .opencode/ folders.

1. Open the Marketplace panel in your IDE (usually Cmd/Ctrl + Shift + P, then search for "Marketplace").
2. Search for ".NET" or "dotnet skills".
3. Install the desired plugins directly by clicking the "Install" button next to each.

For manual installation in Cursor:

• Clone the repository into ~/.cursor/plugins/
• Restart Cursor
• The plugins will appear in the command palette

3. VS Code with GitHub Copilot

For VS Code users, skills can be referenced in Copilot Chat:

1. Install the GitHub Copilot extension
2. Reference skills in chat with @dotnet-skills
3. Use skills inline with comments like // @skill dotnet-msbuild: diagnose build failure

4. OpenAI Codex CLI

For terminal-based workflows using the OpenAI Codex API:

# Install the skill-installer
npm install -g @agentskills/installer

# Add the dotnet marketplace
skill-installer add dotnet/skills

# Install specific skills
skill-installer install dotnet-msbuild

Verification

After installation, verify your setup by asking your AI assistant:

List all installed dotnet skills and their capabilities

The assistant should respond with a summary of each installed plugin and example commands.

Why This Matters for .NET Teams

1. Domain Expertise Over Generative Guessing

General LLMs "hallucinate" when faced with complex MSBuild logs. The dotnet-msbuild skill provides the exact context and heuristics needed to identify root causes in build failures, saving hours of manual log digging.

Consider a typical scenario: Your CI build fails with a cryptic error about assembly versioning conflicts. A general LLM might suggest clearing the NuGet cache or rebuilding. The dotnet-msbuild skill, however, can analyze the binary log, identify that the conflict is between two transitive dependencies that both depend on System.Text.Json but at different versions, and suggest the exact PackageReference override you need.

This level of precision comes from the skill's curated knowledge base of known patterns, not from probabilistic token generation.

2. Safe Modernization

Upgrading a project from .NET 6 to .NET 8 (or the upcoming .NET 11) isn't just about changing a <TargetFramework>. It involves breaking changes, API deprecations, and library updates. The dotnet-upgrade skill automates these transitions while maintaining architectural integrity.

The skill understands migration patterns like:

• Nullable Reference Types: .NET 6+ projects should enable nullable reference types, but the skill helps you do this incrementally per-assembly rather than all at once
• Top-Level Statements: Console apps now use top-level statements by default, but the skill can explain when the traditional Program.cs structure is still appropriate
• Global Usings: The skill can generate sensible GlobalUsings.cs files based on your actual usage patterns
• Minimal Hosting Model: For ASP.NET Core, the skill assists in migrating from Startup.cs to the minimal hosting model in Program.cs

More importantly, it can detect when a breaking change will affect your code before you encounter it at runtime. For example, if you're migrating to .NET 8 and your code uses System.Text.Json serialization of polymorphic types, the skill will warn you about the new type discriminator requirements.

3. Standardized AI Workflows

Because these skills follow the agentskills.io standard, your team can use the same specialized prompts and tools whether they prefer Cursor, VS Code, or the terminal-based Claude Code.

This portability means:

• Consistent Knowledge: A developer switching from Cursor to Claude Code doesn't need to relearn how to ask for build diagnostics
• Shared Skill Marketplace: Your organization can host internal skills in the same format, extending the Microsoft-provided skills with company-specific patterns
• Cross-Platform Collaboration: In code reviews, you can suggest that a teammate "run the dotnet-upgrade skill" without needing to know which editor they use

The standard also ensures that skills are versioned, testable, and reviewable—you can read the SKILL.md file to understand exactly what instructions the AI is following.

4. Reduced Cognitive Load

Senior developers carry immense mental models of .NET's sprawling API surface. By encoding this knowledge into skills, you reduce the need for developers to context-switch between documentation sites, Stack Overflow, and GitHub issues.

Instead of searching for "how to fix CS0006 assembly not found", you can ask:

Diagnose why my build is failing with CS0006

The dotnet-msbuild skill will analyze your project structure, identify missing references or incorrect paths, and suggest the fix—all in one interaction.

5. Onboarding Acceleration

New team members, especially those coming from other ecosystems (Java, Python, Node.js), face a steep learning curve with .NET. These skills act as an always-available mentor.

A junior developer can ask:

How do I set up Entity Framework Core with PostgreSQL?

The dotnet-data skill will:

1. Guide installation of the Npgsql.EntityFrameworkCore.PostgreSQL package
2. Show how to configure the DbContext with connection strings
3. Explain migration workflows
4. Suggest best practices for connection pooling and retry policies

This reduces the time senior developers spend answering repetitive questions and helps juniors become productive faster.

6. Consistency Across Projects

Large organizations often have dozens or hundreds of .NET projects. Maintaining consistency in patterns, dependency versions, and architectural decisions is challenging. The dotnet-template-engine skill helps enforce standards by:

• Creating company-specific project templates with pre-configured logging, telemetry, and security patterns
• Validating that new projects follow organizational conventions
• Generating boilerplate code that matches your team's established patterns

When everyone starts from the same template and uses the same skills for modifications, code reviews become easier and technical debt decreases.

Real-World Use Cases

Scenario 1: CI/CD Build Failure Investigation

Problem: Your CI pipeline fails with a build error that doesn't reproduce locally.

Without Skills: Developers spend hours enabling verbose logging, combing through thousands of lines of build output, and guessing at differences between local and CI environments.

With dotnet-msbuild Skill:

Analyze this CI build failure: [paste error log]

The skill identifies that the CI environment is using a different version of the .NET SDK than specified in global.json, causing MSBuild to resolve different implicit framework references. It suggests adding an explicit SDK version check to your CI script.

Time Saved: 4 hours → 15 minutes

Scenario 2: Dependency Version Conflict

Problem: After updating a NuGet package, your application fails at runtime with FileLoadException due to assembly binding issues.

Without Skills: Developers manually inspect .csproj files, try various version combinations, and eventually resort to adding binding redirects (which don't even work in .NET Core+).

With dotnet-nuget Skill:

Resolve the version conflict between NewtonsoftJson and SystemTextJson

The skill analyzes your dependency graph, identifies that two packages are bringing in incompatible versions, and suggests using a PackageReference version override or migrating to System.Text.Json entirely. It even generates the code changes needed for the migration.

Time Saved: 3 hours → 20 minutes

Scenario 3: Performance Optimization

Problem: Your API endpoint is slow, but you don't know if it's database queries, serialization, or business logic.

Without Skills: Developers instrument code with custom timers, set up profilers like dotTrace or PerfView, and spend significant time interpreting the results.

With dotnet-diag Skill:

Profile the /api/orders endpoint for performance bottlenecks

The skill guides you through:

1. Running dotnet-counters to confirm high database time
2. Collecting an ETW trace during a representative workload
3. Analyzing the trace to identify that Entity Framework is generating N+1 queries
4. Suggesting specific .Include() statements to fix the issue

Time Saved: 6 hours → 1 hour

Scenario 4: Legacy Application Migration

Problem: You need to migrate a .NET Framework 4.7.2 WCF service to .NET 8.

Without Skills: This is a multi-week project involving manual code changes, third-party library research, and extensive testing.

With dotnet-upgrade Skill:

Plan migration from .NET Framework 4.7.2 WCF to .NET 8 gRPC

The skill:

1. Creates a phased migration plan (CoreWCF as intermediate, then gRPC)
2. Identifies which WCF features you're using and their modern equivalents
3. Generates code for gRPC service definitions based on your WCF contracts
4. Suggests testing strategies to ensure behavioral compatibility

Time Saved: 3 weeks → 1 week

Advanced Tips and Best Practices

Combining Multiple Skills

Skills are designed to work together. For complex tasks, you can chain skills:

Use dotnet-nuget to audit vulnerable packages, then use dotnet-upgrade to update them, then use dotnet-test to verify nothing broke

The AI will orchestrate multiple skills in sequence, maintaining context between them.

Custom Skill Extensions

Organizations can extend the official skills with company-specific knowledge. Create a dotnet-mycompany skill that includes:

• Internal library usage patterns
• Approved package lists
• Security scanning requirements
• Deployment procedures specific to your infrastructure

Follow the agentskills.io structure:

dotnet-mycompany/
  SKILL.md           # Instructions for the AI
  templates/         # Code scaffolds
  references/        # Company docs, runbooks
  .agent-skill.json  # Metadata

Skill Versioning

As your projects evolve, pin specific skill versions in your repository:

// .agent-skills.json
{
  "skills": {
    "dotnet-msbuild": "1.2.0",
    "dotnet-nuget": "1.1.3"
  }
}

This ensures consistent behavior across your team and CI/CD pipelines.

Performance Considerations

Skills add a small latency overhead (typically 100-300ms) as the AI loads additional context. For time-critical interactive scenarios, you can:

• Pre-load frequently used skills at session start
• Use skill caching (supported in Claude Code and Cursor)
• Disable unused skills to reduce context window consumption

Troubleshooting Common Issues

Skill Not Found

If you receive "skill not found" errors:

1. Verify the marketplace is added: /plugin marketplace list
2. Check your internet connection (required for initial download)
3. Ensure your AI agent version supports skills (update if needed)
4. Try reinstalling: /plugin uninstall dotnet-msbuild && /plugin install dotnet-msbuild@dotnet-agent-skills

Skill Doesn't Understand My Project

Skills work best with standard .NET project structures. If you have a non-standard setup:

1. Add a README.md in your project root explaining the structure
2. Use explicit paths in your queries: "Analyze the MSBuild project at src/backend/API/API.csproj"
3. Provide additional context: "This is a multi-targeted library that supports .NET Framework 4.6.2 and .NET 6"

Conflicting Advice Between Skills

Occasionally, two skills may suggest different approaches. In these cases:

• Ask the AI to explain the trade-offs: "Compare the dotnet-data suggestion vs. the dotnet-aspnet suggestion"
• Specify your priority: "Prioritize performance over maintainability"
• Consult the SKILL.md files to understand each skill's design philosophy

The Future of Dotnet Skills

The Microsoft .NET team has indicated several exciting directions for the skills repository:

1. Blazor and WebAssembly Skills

Upcoming skills will focus on Blazor development patterns, component architecture, and WebAssembly optimization—areas that have unique challenges not covered by the general dotnet-aspnet skill.

2. Cloud-Native Patterns

New skills are in development for Azure-specific patterns, including:

• Dapr integration for microservices
• Azure Functions authoring and debugging
• App Service deployment and configuration
• Kubernetes manifest generation for .NET apps

3. AI-Generated Skills

Microsoft is experimenting with using AI to generate new skills from documentation and community knowledge, potentially accelerating the pace at which new .NET features get corresponding skill support.

4. Community Contributions

The repository is open to community contributions. If you've developed expertise in a specific area of .NET, you can submit a PR with a new skill. The .NET team provides a contribution guide and skill template to standardize submissions.

Summary

The dotnet/skills repository is a significant step toward "agentic" .NET development. By providing the AI with the same tools and knowledge that human experts use, Microsoft is enabling a more productive, less frustrating development experience.

These skills transform AI assistants from "helpful but occasionally wrong" to "reliably expert" in .NET-specific domains. Whether you're debugging a cryptic build error, planning a multi-step migration, or optimizing database queries, the dotnet skills provide the specialized knowledge that general LLMs simply cannot match.

As the repository matures and the community contributes additional skills, we're moving toward a future where every .NET developer has access to senior-level expertise, regardless of their experience level.

Next Steps:

• Learn about the new Google Search I/O 2026 Agents.
• Explore the full catalog of skills.
• Read our Complete Guide to Agent Skills.
• Understand Codebase Knowledge Graphs.
• Explore our guide on Agent Skills and Security.

This article is based on the state of the dotnet/skills repository as of May 2026. Metrics and features may evolve.