Dotnet Skills: The Official Microsoft Repository for AI Coding Agents
Explore the dotnet/skills repository—a curated collection of AI skills and custom agents for Copilot CLI, Claude Code, and Cursor to enhance .NET development.
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).
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
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
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.
bash
# 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:
Cursor and OpenCode treat the repository as a plugin marketplace or use auto-discovery via .cursor-plugin/ and .opencode/ folders.
Open the Marketplace panel in your IDE (usually Cmd/Ctrl + Shift + P, then search for "Marketplace").
Search for ".NET" or "dotnet skills".
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:
Install the GitHub Copilot extension
Reference skills in chat with @dotnet-skills
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:
bash
# 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:
snippet
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:
snippet
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:
snippet
How do I set up Entity Framework Core with PostgreSQL?
The dotnet-data skill will:
Guide installation of the Npgsql.EntityFrameworkCore.PostgreSQL package
Show how to configure the DbContext with connection strings
Explain migration workflows
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:
snippet
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:
snippet
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:
snippet
Profile the /api/orders endpoint for performance bottlenecks
The skill guides you through:
Running dotnet-counters to confirm high database time
Collecting an ETW trace during a representative workload
Analyzing the trace to identify that Entity Framework is generating N+1 queries
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:
snippet
Plan migration from .NET Framework 4.7.2 WCF to .NET 8 gRPC
The skill:
Creates a phased migration plan (CoreWCF as intermediate, then gRPC)
Identifies which WCF features you're using and their modern equivalents
Generates code for gRPC service definitions based on your WCF contracts
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:
snippet
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:
snippet
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:
Skills work best with standard .NET project structures. If you have a non-standard setup:
Add a README.md in your project root explaining the structure
Use explicit paths in your queries: "Analyze the MSBuild project at src/backend/API/API.csproj"
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.
