How do I install dotnet-skills?

Run these in Claude Code: /plugin marketplace add dotnet/skills. Then prompt normally.

Does dotnet-skills auto-invoke its skills?

Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.

Is dotnet-skills free?

Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Development

Plugin

dotnet-skills

This repository contains the .NET team's curated set of core skills and custom agents for coding agents. For information about the Agent Skills standard, see agentskills.io. 📊 Dashboard - Accuracy and efficiency scoring trends for contained plugins (

FLOW.md

dotnet@dotnet

GitHub

Plugin Signal92/100Strong

maintained100

capable99

documented75

adopted79

Install on Claude Code

> /plugin marketplace add dotnet/skills

Stats

TypeScript JavaScript Node React Bash

+7 tags

C#C++GitHub Anthropic OpenAI iOS Android

5,111

Stars

378

Forks

Active

Maintenance

Language

MIT

License

3h ago

Last commit

6mo ago

Created

Repo: dotnet/skills

In this plugin

96 skills 16 agents

See everything inside

What's inside

Skills

/csharp-scriptsRun file-based C# apps with the .NET CLI when the user explicitly wants C#/.NET code without creating a project. Use for C# language/API experiments, one-file C# apps, small multi-file C# apps composed with `#:include`/`#:exclude`, or C# file-based apps linked with `#:ref`. Do /dotnet-pinvokeCorrectly call native (C/C++) libraries from .NET using P/Invoke and LibraryImport. Covers function signatures, string marshalling, memory lifetime, SafeHandle, and cross-platform patterns. USE FOR: writing new P/Invoke or LibraryImport declarations, reviewing or debugging /nuget-trusted-publishingSet up NuGet trusted publishing (OIDC) on a GitHub Actions repo — replaces long-lived API keys with short-lived tokens. USE FOR: trusted publishing, NuGet OIDC, keyless NuGet publish, migrate from NuGet API key, NuGet/login, secure NuGet publishing. DO NOT USE FOR: publishing to /technology-selectionGuides technology selection and implementation of AI and ML features in .NET 8+ applications using ML.NET, Microsoft.Extensions.AI (MEAI), Microsoft Agent Framework (MAF), GitHub Copilot SDK, ONNX Runtime, and OllamaSharp. Covers the full spectrum from classic ML through modern /configuring-opentelemetry-dotnetConfigure OpenTelemetry distributed tracing, metrics, and logging in ASP.NET Core using the .NET OpenTelemetry SDK. Use when adding observability, setting up OTLP exporters, creating custom metrics/spans, or troubleshooting distributed trace correlation./convert-blazor-server-to-webappGuides conversion of a pre-.NET 8 Blazor Server app into a .NET 8+ Blazor Web App. USE FOR: migrating apps that use AddServerSideBlazor and MapBlazorHub to the AddRazorComponents/MapRazorComponents model, converting _Host.cshtml to an App.razor root component, replacing

Show all 96 skills

/dotnet-webapiGuides creation and modification of ASP.NET Core Web API endpoints with correct HTTP semantics, OpenAPI metadata, and error handling. USE FOR: adding new API endpoints (controllers or minimal APIs), wiring up OpenAPI/Swagger, creating .http test files, setting up global error /minimal-api-file-uploadFile upload endpoints in ASP.NET minimal APIs (.NET 8+)/author-componentCreate or review Blazor components (.razor files) with correct architecture. USE FOR: writing new Blazor components that do NOT involve JavaScript interop, implementing parameters and EventCallback, RenderFragment slots, component lifecycle (OnInitializedAsync, OnParametersSet),/collect-user-inputBuild forms, validate data, and react to user input in Blazor. USE FOR adding forms, search boxes, filter panels, inline editing, data-entry UI, file uploads, validation (annotations or custom), handling form submissions, and binding input controls. Covers EditForm, built-in /configure-authAdd authentication and authorization to a Blazor Web App, accounting for the app's render mode. USE WHEN the user needs [Authorize] on pages, AuthorizeView, role or policy-based access, login/logout Identity pages, or AuthenticationStateProvider. Also USE WHEN auth state is null /coordinate-componentsShare state between components that don't have a direct parent-child parameter relationship, using cascading values, scoped services with change events, or CascadingValueSource via DI. USE WHEN the user needs a CascadingParameter or CascadingValue that works across render mode /create-blazor-projectCreate a new ASP.NET Core web application or web site using Blazor. USE FOR: creating a new Blazor web app, scaffolding a new web project, starting a new web site, choosing render modes (Static SSR, Interactive Server, Interactive WebAssembly, Auto), running dotnet new blazor /fetch-and-send-dataCall APIs, load data into components, and handle the async lifecycle in Blazor. USE FOR fetching data from a backend, submitting data to an API, displaying loading/error states, registering HttpClient, building service abstractions for Auto/WebAssembly render modes. DO NOT USE /plan-ui-changePlan complex Blazor UI features by decomposing them into focused components. USE FOR: building a complex Blazor page with multiple sections, planning component decomposition, designing a multi-section dashboard or layout, breaking down a large UI feature into composable /support-prerenderingMake interactive Blazor components work correctly with prerendering. USE FOR fixing duplicate data loads, UI flicker during prerender-to-interactive handoff, null references during prerender, persisting state across prerender, disabling prerendering, excluding pages from /use-js-interopAdd, review, or fix JavaScript interop in Blazor components. USE FOR: calling JavaScript from Blazor, calling .NET from JavaScript, collocated .razor.js modules, IJSRuntime, IJSObjectReference lifecycle, DotNetObjectReference, ElementReference, timing rules for when JS is /create-datadriven-aspnetcoreGenerate or scaffold ASP.NET Core code — Razor Pages, Blazor components, MVC controllers, views, and Minimal API endpoints — without using ASP.NET Core CLI scaffolding/code-generation tools. Use when (1) adding CRUD pages, views, or API endpoints backed by Entity Framework (EF /optimizing-ef-core-queriesOptimize and improve the performance of slow Entity Framework Core (EF Core) queries: make them generate less SQL, make fewer database round-trips, and return results faster. Use whenever an EF Core or DbContext query or data-access path is slow or should be made faster —/analyzing-dotnet-performanceScans .NET code for ~50 performance anti-patterns across async, memory, strings, collections, LINQ, regex, serialization, and I/O with tiered severity classification. Use when analyzing .NET code for optimization opportunities, reviewing hot paths, or auditing allocation-heavy /android-tombstone-symbolicationSymbolicate the .NET runtime frames in an Android tombstone file. Extracts BuildIds and PC offsets from the native backtrace, downloads debug symbols from the Microsoft symbol server, and runs llvm-symbolizer to produce function names with source file and line numbers. USE FOR /apple-crash-symbolicationSymbolicate .NET runtime frames in Apple platform .ips crash logs (iOS, tvOS, Mac Catalyst, macOS). Extracts UUIDs and addresses from the native backtrace, locates dSYM debug symbols, and runs atos to produce function names with source file and line numbers. Automatically /clr-activation-debuggingDiagnoses .NET Framework CLR activation issues using CLR activation logs (CLRLoad logs) produced by mscoree.dll. Use when: the shim picks the wrong runtime, fails to load any runtime, shows unexpected .NET 3.5 Feature-on-Demand (FOD) dialogs, unexpectedly does NOT show FOD /dotnet-trace-collectGuide developers through capturing diagnostic artifacts to diagnose production .NET performance issues. Use when the user needs help choosing diagnostic tools, collecting performance data, or understanding tool trade-offs across different environments (Windows/Linux, .NET /dump-collectConfigure and collect crash dumps for modern .NET applications. USE FOR: enabling automatic crash dumps for CoreCLR or NativeAOT, capturing dumps from running .NET processes, setting up dump collection in Docker or Kubernetes, using dotnet-dump collect or createdump. DO NOT USE /microbenchmarkingActivate this skill when BenchmarkDotNet (BDN) is involved in the task — creating, running, configuring, or reviewing BDN benchmarks. Also activate when microbenchmarking .NET code would be useful and BenchmarkDotNet is the likely tool. Consider activating when answering a .NET /exp-mock-usage-analysisAudits .NET test mock usage by tracing each mock setup through the production code's execution path to find dead, unreachable, redundant, or replaceable mocks. Use when the user asks to audit mock usage, find unused or unnecessary mock setups, check if mocks are needed, reduce /exp-simd-vectorizationOptimizes hot-path scalar loops in .NET 8+ with cross-platform Vector128/Vector256/Vector512 SIMD intrinsics, or replaces manual math loops with single TensorPrimitives API calls. Covers byte-range validation, character counting, bulk bitwise ops, cross-type conversion, fused /exp-test-maintainabilityDetects duplicate boilerplate, copy-paste tests, and structural maintainability issues across .NET test suites. Use when the user asks to reduce repetition, consolidate similar test methods, convert copy-paste tests to data-driven parameterized tests, suggest a better test /dotnet-maui-doctorDiagnoses and fixes .NET MAUI development environment issues. Validates .NET SDK, workloads, Java JDK, Android SDK, Xcode, and Windows SDK. All version requirements discovered dynamically from NuGet WorkloadDependencies.json — never hardcoded. Use when: setting up MAUI /maui-app-lifecycle.NET MAUI app lifecycle guidance — the four app states, cross-platform Window lifecycle events (Created, Activated, Deactivated, Stopped, Resumed, Destroying), platform-specific lifecycle mapping, backgrounding and resume behavior, and state-preservation patterns. USE FOR: "app /maui-collectionviewGuidance for implementing CollectionView in .NET MAUI apps — data display, layouts (list & grid), selection, grouping, scrolling, empty views, templates, incremental loading, swipe actions, and pull-to-refresh. USE FOR: "CollectionView", "list view", "grid layout", "data /maui-data-bindingGuidance for .NET MAUI XAML and C# data bindings — compiled bindings, INotifyPropertyChanged / ObservableObject, value converters, binding modes, multi-binding, relative bindings, fallbacks, and MVVM best practices. USE FOR: setting up compiled bindings with x:DataType,/maui-dependency-injectionGuidance for configuring dependency injection in .NET MAUI apps — service registration in MauiProgram.cs, lifetime selection (Singleton / Transient / Scoped), constructor injection, Shell navigation auto-resolution, platform-specific registrations, and testability patterns. USE /maui-safe-area.NET MAUI safe area and edge-to-edge layout guidance for .NET 10+. Covers the new SafeAreaEdges property, SafeAreaRegions enum, per-edge control, keyboard avoidance, Blazor Hybrid CSS safe areas, migration from legacy iOS-only APIs, and platform-specific behavior for Android,/maui-shell-navigationGuide for implementing Shell-based navigation in .NET MAUI apps. Covers AppShell setup, visual hierarchy (FlyoutItem, TabBar, Tab, ShellContent), URI-based navigation with GoToAsync, route registration, query parameters, back navigation, flyout and tab configuration, navigation /maui-themingGuide for theming .NET MAUI apps — light/dark mode via AppThemeBinding, ResourceDictionary theme switching, DynamicResource bindings, system theme detection, and user theme preferences. Use when: "dark mode", "light mode", "theming", "AppThemeBinding", "theme switching",/binlog-failure-analysisAnalyze MSBuild binary logs to diagnose build failures. USE FOR: build errors that are unclear from console output, diagnosing cascading failures across multi-project builds, tracing MSBuild target execution order, and generally any MSBuild build issues. Requires an existing /binlog-generationGenerate MSBuild binary logs (binlogs) for build diagnostics and analysis. USE FOR: adding /bl:{} to any dotnet build, test, pack, publish, or restore command to capture a full build execution trace, prerequisite for binlog-failure-analysis and build-perf-diagnostics skills,/build-parallelismDiagnose and fix under-parallelized MSBuild builds. USE WHEN a multi-project solution build is slower than expected, doesn't speed up when you add cores, pegs a single core while others idle, or you want to know why `-m` isn't helping. Note: `/maxcpucount` default is 1 /build-perf-baselineEstablish build performance baselines and apply systematic optimization techniques. USE FOR: diagnosing slow builds, establishing before/after measurements (cold, warm, no-op scenarios), applying optimization strategies like MSBuild Server, static graph builds, artifacts output,/build-perf-diagnosticsDiagnose MSBuild build performance bottlenecks using binary log analysis. USE FOR: identifying why builds are slow by analyzing binlog performance summaries, detecting ResolveAssemblyReference (RAR) taking >5s, Roslyn analyzers consuming >30% of Csc time, single targets /check-bin-obj-clashDetects MSBuild projects with conflicting OutputPath or IntermediateOutputPath. USE FOR: builds failing with 'Cannot create a file when that file already exists', 'The process cannot access the file because it is being used by another process', intermittent build failures that /copy-to-output-directoryChoosing an MSBuild CopyToOutputDirectory / CopyToPublishDirectory mode: Never, PreserveNewest, Always, and IfDifferent (MSBuild 17.13+), plus $(SkipUnchangedFilesOnCopyAlways). USE FOR: removing the per-build Always copy perf hit; resetting output files mutated between builds./directory-build-organizationGuide for organizing MSBuild infrastructure with Directory.Build.props, Directory.Build.targets, Directory.Packages.props, and Directory.Build.rsp. USE FOR: structuring multi-project repos, centralizing build settings, implementing NuGet Central Package Management (CPM) with /eval-performanceGuide for diagnosing and improving MSBuild project evaluation performance. USE FOR: builds slow before any compilation starts, high evaluation time in binlog analysis, expensive glob patterns walking large directories (node_modules, .git, bin/obj), deep import chains (>20 /extension-pointsGuide for MSBuild extensibility: CustomBefore/CustomAfter hooks, wildcard imports with alphabetic ordering, import gating with control properties, NuGet package build extension layout (build/buildTransitive), and the MicrosoftCommonPropsHasBeenImported guard. USE FOR: diagnosing /including-generated-filesFix MSBuild targets that generate files during the build but those files are missing from compilation or output. USE FOR: generated source files not compiling (CS0246 for a type that should exist), custom build tasks that create files but they are invisible to subsequent /incremental-buildGuide for optimizing MSBuild incremental builds. USE FOR: builds slower than expected on subsequent runs, 'nothing changed but it rebuilds anyway', diagnosing why targets re-execute unnecessarily, fixing broken no-op builds. Covers 8 common causes: missing Inputs/Outputs on /item-managementPatterns for managing MSBuild item groups: Include/Remove/Update semantics, item metadata, batching with %(Metadata), transforms, per-item filtering, and cross-product batching pitfalls. USE FOR: diagnosing and fixing item group anti-patterns in .csproj files, reviewing item /msbuild-antipatternsDetect and fix MSBuild anti-patterns in project and build files. USE WHEN asked to review, audit, lint, clean up, or code-review a .csproj/.vbproj/.fsproj/.props/.targets/.proj (or Directory.Build.props/.targets) file, when asked 'is this project file correct?' or 'what's wrong /msbuild-modernizationGuide for modernizing and migrating MSBuild project files to SDK-style format. USE FOR: converting legacy .csproj/.vbproj with verbose XML to SDK-style, migrating packages.config to PackageReference, removing Properties/AssemblyInfo.cs in favor of auto-generation, eliminating /msbuild-serverGuide for using MSBuild Server to improve CLI build performance. Activate when developers report slow incremental builds from the command line, or when CLI builds are noticeably slower than IDE builds. Covers MSBUILDUSESERVER=1 environment variable for persistent server-based /property-patternsMSBuild property definition patterns: conditional defaults, composition/concatenation, path normalization, trailing-slash handling, TFM detection helpers, and evaluation order. USE FOR: diagnosing and fixing property definition issues and shared-property anti-patterns in /resolve-project-referencesGuide for interpreting ResolveProjectReferences time in MSBuild performance summaries. Activate when ResolveProjectReferences appears as the most expensive target and developers are trying to optimize it directly. Explains that the reported time includes wait time for dependent /target-authoringCanonical patterns for writing custom MSBuild targets. USE FOR: diagnosing and fixing custom target authoring anti-patterns; broken SDK target chains across files (e.g., Directory.Build.targets silently redefining SDK targets); targets that replace CompileDependsOn instead of /convert-to-cpmConvert .NET projects and solutions (.sln, .slnx) to NuGet Central Package Management (CPM) using Directory.Packages.props. USE FOR: converting to CPM, centralizing or aligning NuGet package versions across multiple projects, inlining MSBuild version properties from /template-authoringGuides creation and validation of custom dotnet new templates from existing projects. Generates a .template.config/template.json that preserves the source project's conventions. USE FOR: creating a reusable dotnet new template from an existing project, bootstrapping /template-comparisonCompares two or more dotnet new templates side by side to help users choose between them based on parameters, feature support, frameworks, and classifications. USE FOR: deciding between similar templates (webapi vs webapp, blazor vs blazorwasm, console vs worker), producing a /template-discoveryHelps find, inspect, and compare (at a high level) .NET project templates. Resolves natural-language project descriptions to ranked template matches with pre-filled parameters. USE FOR: finding the right dotnet new template for a task, inspecting a template's parameters and /template-instantiationCreates .NET projects from templates with validated parameters, smart defaults, Central Package Management adaptation, and latest NuGet version resolution. USE FOR: creating new dotnet projects, scaffolding solutions with multiple projects, installing or uninstalling template /template-smart-defaultsApplies cross-parameter default rules when creating .NET projects with dotnet new, filling gaps consistently without overriding values the user set explicitly. USE FOR: choosing which target framework to pair with native AOT, deciding whether to keep HTTPS when authentication is /template-validationValidates custom dotnet new templates for correctness before publishing. Catches missing fields, parameter bugs, shortName conflicts, constraint issues, and common authoring mistakes that cause templates to fail silently. USE FOR: checking template.json files for errors before /migrate-mstest-v1v2-to-v3Migrate MSTest v1/v2 projects to MSTest v3, and fix v1/v2-to-v3 breaking changes that surface after the packages are already at 3.x. USE FOR: removing v1 Microsoft.VisualStudio.QualityTools.UnitTestFramework assembly references; moving MSTest.TestFramework/TestAdapter 1.x-2.x to /migrate-mstest-v3-to-v4Fix build errors and breaking changes after upgrading MSTest v3 to v4, or plan a complete v3-to-v4 migration. Use when user says "upgrade to MSTest v4", "MSTest 4 migration", "MSTest v4 breaking changes", "tests don't compile after upgrading MSTest 3.x to 4.x", or hits CS0507,/migrate-vstest-to-mtpMigrates .NET test projects from VSTest to Microsoft.Testing.Platform (MTP). Use when user asks to "migrate to MTP", "switch from VSTest", "enable Microsoft.Testing.Platform", "use MTP runner", set OutputType=Exe only for test projects in Directory.Build.props, or mentions /migrate-xunit-to-mstestConvert .NET test projects from xUnit.net v2 or v3 to MSTest v4. Use for replacing xunit packages, [Fact]/[Theory], xUnit assertions, fixtures, ITestOutputHelper, traits, skips, and xUnit parallelization with MSTest equivalents while preserving the current VSTest or MTP runner./migrate-xunit-to-xunit-v3Migrates .NET test projects from xUnit.net v2 to xUnit.net v3. USE FOR: upgrading xunit to xunit.v3. DO NOT USE FOR: migrating between test frameworks (MSTest/NUnit to xUnit.net), migrating from VSTest to Microsoft.Testing.Platform (use migrate-vstest-to-mtp). For xUnit v3 MTP /assertion-qualityMANDATORY for reviewing assertion strength, depth, and variety in existing tests. Invoke when the user asks whether individual assertions are weak, shallow, trivial, always true, self-referential, or diverse; asks which tests are assertion-free or rely only on /code-testing-agentMANDATORY ENTRY POINT for generating or writing tests. Invoke this skill before editing files whenever the user asks to generate tests, write/add unit tests, scaffold a test project or suite, improve/achieve coverage, extend an existing suite to cover an untested method, or test /code-testing-extensionsProvides file paths to language-specific extension files for the code-testing pipeline. Call this skill to discover available extension guidance files (e.g., dotnet.md for .NET, cpp.md for C++). Do not use directly — invoked by code-testing agents and skills that need /coverage-analysisProject-wide code coverage and CRAP (Change Risk Anti-Patterns) score analysis for .NET projects. Calculates CRAP scores per method and surfaces risk hotspots — complex code with low coverage that is dangerous to modify. Use to diagnose why coverage is stuck or plateaued,/crap-scoreCalculates targeted CRAP (Change Risk Anti-Patterns) scores for a named .NET method, class, or single source file. Use when the user explicitly asks to compute CRAP scores or assess risky untested code for a specific target, combining Cobertura coverage data with cyclomatic /detect-static-dependenciesScan C# source files for hard-to-test static dependencies — DateTime.Now/UtcNow, File.*, Directory.*, Environment.*, HttpClient, Console.*, Process.*, and other untestable statics. Produces a ranked report of static call sites by frequency. USE FOR: find untestable statics, scan /filter-syntaxReference data for test filter syntax across all platform and framework combinations: VSTest --filter expressions, MTP filters for MSTest/NUnit/xUnit v3/TUnit, and VSTest-to-MTP filter translation. DO NOT USE directly — loaded by run-tests, mtp-hot-reload, and /find-untested-sourcesMANDATORY for static requests to find, identify, or list untested source files or modules, sources without tests, source-to-test pairing, test-gap worklists, or suggested test locations. Invoke even for a tiny package; do not substitute manual globbing. Uses Roslyn for C#/.NET /generate-testability-wrappersGenerate wrapper interfaces and DI registration for hard-to-test static dependencies in C#, when the abstraction does NOT exist yet. Produces IFileSystem, IEnvironmentProvider, IConsole, IProcessRunner wrappers, or guides first-time adoption of TimeProvider and /grade-testsGrades a specified set of test methods individually and produces a concise table mapping each test (fully-qualified name) to a letter grade (A–F), a score band, and a one-line note — designed to be posted as a PR comment. Use when the caller wants per-test feedback on a curated /migrate-static-to-wrapperReplace existing static dependency call sites with a wrapper or built-in abstraction that already exists or is registered in DI, across a bounded scope (file, project, namespace). USE FOR: replace DateTime.UtcNow/DateTime.Now with TimeProvider and add the constructor parameter,/mtp-hot-reloadSuggests using Microsoft Testing Platform (MTP) hot reload to iterate fixes on failing tests without rebuilding. Use when user says "hot reload tests", "iterate on test fix", "run tests without rebuilding", "speed up test loop", "fix test faster", or needs to set up MTP hot /platform-detectionReference data for detecting the test platform (VSTest vs Microsoft.Testing.Platform) and test framework (MSTest, xUnit, NUnit, TUnit) from project files. DO NOT USE directly — loaded by run-tests, mtp-hot-reload, and migrate-vstest-to-mtp when they need detection logic./run-testsRecommend or run the exact `dotnet test` command. ALWAYS use when the user asks to run, filter, or troubleshoot .NET tests or wants the precise command, flags, or argument order — the right syntax depends on the test platform (VSTest vs Microsoft.Testing.Platform) and SDK /test-analysis-extensionsProvides file paths to language-specific reference files for the test ANALYSIS skills (assertion-quality, test-anti-patterns, test-gap-analysis, test-smell-detection, test-tagging). Call this skill to discover available extension files (e.g., dotnet.md for /test-anti-patternsAudits an existing test file or suite in any language for anti-patterns and quality issues — produces a severity-ranked report (Critical/Warning/Info). INVOKE whenever asked to audit or review tests, find what's wrong with a suite, judge whether tests are any good, or check for:/test-gap-analysisPerforms pseudo-mutation analysis on production code in any language to find gaps in existing tests. Use when the user asks to find weak or shallow tests, discover untested edge cases, or check whether tests would catch a bug — e.g. \"would my tests catch it if someone changed /test-smell-detectionDeep-dive audit using the full testsmells.org 19-smell academic catalog for tests in any language. Every finding maps to a named, citable smell from the research literature (Assertion Roulette, Duplicate Assert, Mystery Guest, Eager Test, Sensitive Equality, Conditional Test /test-taggingAnalyzes test suites in any language and tags each test with standardized traits (positive, negative, critical-path, boundary, smoke, regression, integration, performance, security). Use when the user wants to categorize, audit, or label tests with traits. Works across .NET /writing-mstest-testsWrite, create, modernize, or fix comprehensive MSTest unit tests with MSTest 3.x/4.x APIs. USE FOR: write, create, review, or modernize MSTest tests and assertions, better MSTest assertion than Assert.IsTrue, replace hard cast with IsInstanceOfType, MSTest assertion APIs /dotnet-aot-compatMake .NET projects compatible with Native AOT and trimming by systematically resolving IL trim/AOT analyzer warnings. USE FOR: making projects AOT-compatible, fixing trimming warnings, resolving IL warnings (IL2026, IL2070, IL2067, IL2072, IL3050), adding /migrate-dotnet10-to-dotnet11Migrate a .NET 10 project or solution to .NET 11 and resolve all breaking changes. This is a MIGRATION skill — use it when upgrading from .NET 10 to .NET 11, NOT for writing new programs. USE FOR: upgrading TargetFramework from net10.0 to net11.0, fixing build errors after /migrate-dotnet8-to-dotnet9Migrate a .NET 8 project to .NET 9 and resolve all breaking changes. USE FOR: upgrading TargetFramework from net8.0 to net9.0, fixing build errors after updating the .NET 9 SDK, resolving behavioral changes in .NET 9 / C# 13 / ASP.NET Core 9 / EF Core 9, replacing /migrate-dotnet9-to-dotnet10Migrate a .NET 9 project or solution to .NET 10 and resolve all breaking changes. USE FOR: upgrading TargetFramework from net9.0 to net10.0, fixing build errors after updating the .NET 10 SDK, resolving source and behavioral changes in .NET 10 / C# 14 / ASP.NET Core 10 / EF Core /migrate-nullable-referencesEnable nullable reference types in a C# project and systematically resolve all warnings. USE FOR: adopting NRTs in existing codebases, file-by-file or project-wide migration, fixing CS8602/CS8618/CS86xx warnings, annotating APIs for nullability, cleaning up null-forgiving /thread-abort-migrationGuides migration of .NET Framework Thread.Abort usage to cooperative cancellation in modern .NET. USE FOR: modernizing code that calls Thread.Abort, catching ThreadAbortException, replacing Thread.ResetAbort, replacing Thread.Interrupt for thread termination, resolving /setup-local-sdkInstall a .NET SDK locally for safe preview testing, specific-version pinning, or reproducible team setups — without modifying the system-wide installation. USE FOR: trying .NET previews safely, testing specific SDK versions, installing MAUI or other workloads on a preview,/system-text-json-net11Imperative guidance for the System.Text.Json APIs added in .NET 11: the built-in `JsonNamingPolicy.PascalCase` naming policy, and the strongly-typed `JsonSerializerOptions.GetTypeInfo<T>()` and `JsonSerializerOptions.TryGetTypeInfo<T>(out JsonTypeInfo<T>? info)` metadata

Agents

optimizing-dotnet-performance.agentAnalyzes .NET code for performance bottlenecks, recommends concrete optimizations, and guides benchmarking. Scans for ~50 anti-patterns across async, memory, strings, collections, LINQ, regex, serialization, and I/O. Use when reviewing .NET code performance, optimizing hot build-perf.agentAgent for diagnosing and optimizing MSBuild build performance. Runs multi-step analysis: generates binlogs, analyzes timeline and bottlenecks, identifies expensive targets/tasks/analyzers, and suggests concrete optimizations. Invoke when builds are slow or when asked to optimize msbuild-code-review.agentAgent that reviews MSBuild project files for anti-patterns, modernization opportunities, and best practices violations. Scans .csproj, .vbproj, .fsproj, .props, .targets files and produces actionable improvement suggestions. Invoke when asked to review, audit, or improve MSBuild msbuild.agentExpert agent for MSBuild and .NET build troubleshooting, optimization, and project file quality. Routes to specialized agents for performance analysis and code review. Verifies MSBuild domain relevance before deep-diving. Specializes in build configuration, error diagnosis,template-engine.agentExpert agent for .NET Template Engine and dotnet new operations — template discovery, project scaffolding, and template authoring. Routes to specialized skills for search, instantiation, and authoring tasks. Verifies template-engine domain relevance before deep-diving.test-migration.agentOrchestrates .NET test framework and platform migrations: auto-detects the current framework and version, routes to the appropriate migration skill, and guides users through end-to-end upgrades. Use when asked to upgrade MSTest, migrate to xUnit v3, switch to

Show all 16 agents

code-testing-builder.agentRuns build/compile commands for any language and reports results. Use when: compiling code, running dotnet build, checking for compilation errors, verifying project builds successfully.code-testing-fixer.agentFixes compilation errors in source or test files. Use when: resolving build errors, fixing CS/TS error codes, adding missing imports, correcting type mismatches, fixing compilation failures.code-testing-generator.agentInternal implementation agent for the code-testing-agent skill. Orchestrates the Research-Plan-Implement pipeline after that public entry-point skill delegates a test-generation request. Do not route user prompts here directly.code-testing-implementer.agentImplements a single phase from the test plan. Writes test files and verifies they compile and pass. Use when: executing a plan phase, writing test files, running build-test-fix cycle for generated tests.code-testing-linter.agentRuns code formatting and linting for any language. Use when: formatting code, running dotnet format, fixing style issues, applying lint fixes.code-testing-planner.agentCreates structured test implementation plans from research findings. Use when: organizing tests into phases, prioritizing test generation, creating .testagent/plan.md from research.code-testing-researcher.agentAnalyzes codebases to understand structure, testing patterns, and testability. Use when: researching project structure, identifying source files to test, discovering test frameworks and build commands, producing .testagent/research.md.code-testing-tester.agentRuns test commands for any language and reports pass/fail results. Use when: running dotnet test, executing tests, verifying tests pass, checking test results and failures.test-quality-auditor.agentRuns multi-skill audit pipelines for comprehensive test suite assessment across a workspace or project, combining assertion quality, test smell detection, mock usage analysis, test gap analysis, coverage risk, and test tagging into unified reports. Polyglot: .NET testability-migration.agentOrchestrates end-to-end testability migration for .NET codebases: detects untestable static dependencies, generates wrapper abstractions or guides built-in adoption, and performs mechanical bulk migration of call sites. Use when asked to make code testable, remove static

Badges

README

Read on GitHub

.NET Agent Skills

This repository contains the .NET team's curated set of core skills and custom agents for coding agents. For information about the Agent Skills standard, see agentskills.io.

📊 Dashboard - Accuracy and efficiency scoring trends for contained plugins (https://dotnet.github.io/skills/)

What's Included

Plugin	Description
dotnet	C# language server (LSP) integration for coding agents and high-level .NET development skills.
dotnet-advanced	Collection of .NET skills for handling specific .NET tasks for special scenarios.
dotnet-data	Skills for .NET data access and Entity Framework related tasks.
dotnet-diag	Skills for .NET performance investigations, debugging, and incident analysis.
dotnet-msbuild	Comprehensive MSBuild and .NET build skills: failure diagnosis, performance optimization, code quality, and modernization.
dotnet-nuget	NuGet and .NET package management: dependency management and modernization.
dotnet-upgrade	Skills for migrating and upgrading .NET projects across framework versions, language features, and compatibility targets.
dotnet-maui	Skills for .NET MAUI development: environment setup, diagnostics, and troubleshooting.
dotnet-ai	AI and ML skills for .NET: technology selection, LLM integration, agentic workflows, RAG pipelines, MCP, and classic ML with ML.NET.
dotnet-template-engine	.NET Template Engine skills: template discovery, project scaffolding, and template authoring.
dotnet-test	Skills for running, generating, analyzing, and improving .NET tests: test execution, filtering, platform detection, coverage, testability, and MSTest workflows.
dotnet-test-migration	Skills and an orchestrator agent for migrating .NET test frameworks and platforms: MSTest and xUnit version upgrades, xUnit-to-MSTest conversion, and VSTest to Microsoft.Testing.Platform.
dotnet-aspnetcore	ASP.NET Core web development skills including middleware, endpoints, real-time communication, and API patterns.
dotnet-blazor	Skills for Blazor development: component authoring, interactivity, and web application patterns.
dotnet11	Skills for new .NET 11 APIs and language features.

Installation

🚀 Plugins - Copilot CLI / Claude Code

Launch Copilot CLI or Claude Code
Add the marketplace:
```
/plugin marketplace add dotnet/skills
```

Install a plugin:

/plugin install <plugin>@dotnet-agent-skills

Restart to load the new plugins
View available skills:
```
/skills
```
View available agents:
```
/agents
```

Update plugin (on demand):

/plugin update <plugin>@dotnet-agent-skills

VS Code / VS Code Insiders (Preview)

[!IMPORTANT]
VS Code plugin support is a preview feature and subject to change. You may need to enable it first.

// settings.json
{
  "chat.plugins.enabled": true,
  "chat.plugins.marketplaces": ["dotnet/skills"]
}

Once configured, type /plugins in Copilot Chat or use the @agentPlugins filter in Extensions to browse and install plugins from the marketplace.

Cursor

This repository is a Cursor plugin marketplace. You can discover and install published plugins directly in Cursor:

Open the marketplace panel in Cursor
Search for .NET or browse cursor.com/marketplace
Install the desired plugins

For local development or unpublished changes, import plugins from a local checkout:

Copy or symlink your local checkout to ~/.cursor/plugins/local/dotnet-agent-skills
Restart Cursor or run Developer: Reload Window

Codex CLI

Skills in this repository follow the agentskills.io open standard and are compatible with OpenAI Codex.

Plugin marketplace (recommended)

Codex CLI v0.121.0 and later supports a plugin marketplace. This repository ships a Codex-native marketplace manifest at .agents/plugins/marketplace.json, so you can register dotnet/skills as a marketplace and install plugins from it directly.

Add the marketplace:

codex plugin marketplace add dotnet/skills

Launch Codex and open the plugin browser:
```
/plugins
```
Browse the dotnet-agent-skills tab and install the desired plugins.

Update plugins on demand:

codex plugin marketplace upgrade dotnet-agent-skills

Individual skills

You can also install individual skills using the skill-installer CLI with the GitHub URL:

$ skill-installer install https://github.com/dotnet/skills/tree/main/plugins/<plugin>/skills/<skill-name>

Contributing

See CONTRIBUTING.md for contribution guidelines and how to add a new plugin.

License

See LICENSE for details.

File tree

1292

dotnet/skillsView on GitHub

.agents/
  plugins/
    marketplace.json
  skills/
    authoring-github-workflows/
      SKILL.md
    create-custom-agent/
      SKILL.md
    create-skill/
    create-skill-test/
      SKILL.md
      SKILL.md
    improve-skill-quality/
      references/
        eval-triage.md
        writing-for-baseline-delta.md
      SKILL.md
.claude-plugin/
  marketplace.json
.config/
  dotnet-tools.json
.cursor-plugin/
  marketplace.json
.gitattributes
.github/
  actionlint.yaml
  agents/
    agentic-workflows.md
  aw/
    actions-lock.json
    shared/
      devops-health.lock.md
      devops-investigate.lock.md
  CODEOWNERS
  dependabot.yml
  plugin/
    marketplace.json
  prompts/
    evaluate-skill-descriptions.prompt.md
  pull_request_template.md
  scripts/
    pr-stale-sweep.sh
    pr-triage-act.sh
  skills/
    agentic-workflows/
      SKILL.md
  workflows/
    actionlint.yml
    agentics-maintenance.yml
    codeowners-folder-validation.yml
    copilot-setup-steps.yml
    devops-health-check.lock.yml
    devops-health-check.md
    devops-health-cleanup.yml
    devops-health-groom.lock.yml
    devops-health-groom.md
    devops-health-investigate.lock.yml
    devops-health-investigate.md
    eval-quality.yml
    evaluation-run.yml
    evaluation-workflow-tests.yml
    evaluation.yml
    fork-infra-check.yml
    gh-aw-upgrade.yml
    issue-investigate.lock.yml
    issue-investigate.md
    issue-triage-batch.yml
    issue-triage.lock.yml
    issue-triage.md
    markdown-linter.lock.yml
    markdown-linter.md
    markdownlint.yml
    pr-malicious-scan.agent.lock.yml
    pr-malicious-scan.agent.md
    pr-triage-batch.yml
    pr-triage.yml
    shared/
      pat_pool.md
      pat_pool.README.md
    skill-check.yml
    skill-coverage.yml
    skill-validator.yml
    validate-pat-pool.yml
    version-bump-command.yml
    weekly-version-sync.yml
.gitignore
.markdownlint-cli2.jsonc
.vscode/
  extensions.json
AGENTS.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
docs/
  agentic-workflows.md
  design/
    pr-triage-workflows.md
  dotnet-experimental/
    exp-mock-usage-analysis-design-notes.md
    exp-test-maintainability-design-notes.md
dotnet-skills.experiment.yaml
eng/
  allowed-external-deps.txt
  dashboard/
    build-replay-sessions.ps1
    dashboard.html
    dashboard.js
    generate-benchmark-data.ps1
    generate-token-data.ps1
    purge-replay-sessions.ps1
    token-usage.js
  eval-quality/
    check_eval_quality.py
    README.md
    selftest_eval_quality.py
    underpowered-allowlist.txt
  evaluation/
    nuget.config
    test_token_failover.py
  known-domains.txt
  run-skill-evals.sh
  skill-coverage/
    Measure-SkillCoverage.ps1
  skill-validator/
    .editorconfig
    Directory.Build.props
    SkillValidator.slnx
    src/
      Check/
        AgentProfiler.cs
        CheckCommand.cs
        CheckJsonSerializerContext.cs
        ExternalDependencyChecker.cs
        Models.cs
        PluginProfiler.cs
        ReferenceScanner.cs
        SkillProfiler.cs
      docs/
        InvestigatingResults.md
        OverfittingDetection.md
      Evaluate/
        AgentRunner.cs
        AssertionEvaluator.cs
        BaselineStore.cs
        Comparator.cs
        ConsolidateCommand.cs
        EvalSchema.cs
        EvaluateCommand.cs
        Judge.cs
        LlmSession.cs
        LocalSessionFsHandler.cs
        MetricsCollector.cs
        Models.cs
        OverfittingCommand.cs
        OverfittingJudge.cs
        PairwiseJudge.cs
        RejudgeCommand.cs
        Reporter.cs
        SessionDatabase.cs
        Statistics.cs
      Program.cs
      README.md
      Shared/
        AgentDiscovery.cs
        Ansi.cs
        ConcurrencyLimiter.cs
        FrontmatterParser.cs
        LlmJson.cs
        Models.cs
        PluginDiscovery.cs
        RetryHelper.cs
        SkillDiscovery.cs
        Spinner.cs
      SkillValidator.csproj
      SkillValidatorJsonContext.cs
      SkillValidatorYamlContext.cs
    tests/
      Check/
        AgentPluginTests.cs
        CheckCommandTests.cs
        ExternalDependencyTests.cs
        ReferenceScannerTests.cs
        SkillProfileTests.cs
      Evaluate/
        AssertionsTests.cs
        BaselineStoreTests.cs
        ComparatorTests.cs
        EvalDiscoveryTests.cs
        EvalSchemaTests.cs
        EvaluateCommandTests.cs
        FailureIsolationTests.cs
        JudgeTests.cs
        MetricsTests.cs
        OverfittingCommandTests.cs
        OverfittingJudgeTests.cs
        PairwiseJudgeTests.cs
        RejudgeCommandTests.cs
        RunnerTests.cs
        SessionDatabaseTests.cs
        StatisticsTests.cs
      fixtures/
        no-eval-skill/
          SKILL.md
        sample-skill/
          SKILL.md
          tests/
            eval.yaml
      Shared/
        ConcurrencyLimiterTests.cs
        DiscoveryTests.cs
        LlmJsonTests.cs
        RetryHelperTests.cs
      SkillValidator.Tests.csproj
  vally-adapter/
    adapt.mjs
    adapt.test.mjs
    consolidate.mjs
    docs/
      images/
        vally-pr-comment-before.png
        vally-pr-comment-edge-cases.png
        vally-pr-comment-example.png
    gen-experiment.mjs
    InvestigatingResults.md
    README.md
  version/
    nuget.config
    Sync-PluginVersions.ps1
global.json
LICENSE
plugins/
  dotnet/
  dotnet-advanced/
    .codex-plugin/
      plugin.json
    plugin.json
    README.md
    skills/
      csharp-scripts/
        SKILL.md
      dotnet-pinvoke/
        references/
          diagnostics.md
          type-mapping.md
        SKILL.md
      nuget-trusted-publishing/
        references/
          package-types.md
          publish-workflow.md
        SKILL.md
    version.json
  dotnet-ai/
    .codex-plugin/
      plugin.json
    plugin.json
    skills/
      technology-selection/
        SKILL.md
    version.json
  dotnet-aspnetcore/
    .codex-plugin/
      plugin.json
    plugin.json
    skills/
      configuring-opentelemetry-dotnet/
        SKILL.md
      convert-blazor-server-to-webapp/
        SKILL.md
      dotnet-webapi/
        SKILL.md
      minimal-api-file-upload/
        SKILL.md
    version.json
  dotnet-blazor/
    .codex-plugin/
      plugin.json
    plugin.json
    skills/
      author-component/
        references/
          async-programming-rules.md
          breaking-down-components.md
          component-disposal.md
        SKILL.md
      collect-user-input/
        SKILL.md
      configure-auth/
        SKILL.md
      coordinate-components/
        SKILL.md
      create-blazor-project/
        assets/
          agents-md/
            auto-global.md
            auto-per-page.md
            server-global.md
            server-per-page.md
            ssr-none.md
            webassembly-global.md
            webassembly-per-page.md
        SKILL.md
      fetch-and-send-data/
        SKILL.md
      plan-ui-change/
        SKILL.md
      support-prerendering/
        SKILL.md
      use-js-interop/
        SKILL.md
    version.json
  dotnet-data/
    .codex-plugin/
      plugin.json
    plugin.json
    skills/
      create-datadriven-aspnetcore/
        SKILL.md
      optimizing-ef-core-queries/
        SKILL.md
    version.json
  dotnet-diag/
    .codex-plugin/
      plugin.json
    agents/
      optimizing-dotnet-performance.agent.md
    plugin.json
    skills/
      analyzing-dotnet-performance/
        references/
          async-patterns.md
          collections-and-linq.md
          critical-patterns.md
          io-and-serialization.md
          memory-and-strings.md
          regex-patterns.md
          structural-patterns.md
        SKILL.md
      android-tombstone-symbolication/
        scripts/
          Symbolicate-Tombstone.ps1
        SKILL.md
      apple-crash-symbolication/
        references/
          ips-crash-format.md
        scripts/
          Symbolicate-Crash.ps1
        SKILL.md
      clr-activation-debugging/
        references/
          activation-flow.md
          com-activation.md
          log-format.md
        SKILL.md
      dotnet-trace-collect/
        references/
          dotnet-monitor.md
          dotnet-trace-collect-linux.md
          dotnet-trace-collect.md
          perfcollect.md
          perfview.md
        SKILL.md
      dump-collect/
        references/
          container-dumps.md
          coreclr-dumps.md
          nativeaot-dumps.md
        SKILL.md
      microbenchmarking/
        references/
          bdn-internals-and-tuning.md
          comparison-strategies.md
          diagnosers-and-exporters.md
          project-setup-and-running.md
          writing-benchmarks.md
        SKILL.md
    training-logs/
      apple-crash-symbolication.md
    version.json
  dotnet-experimental/
    .codex-plugin/
      plugin.json
    plugin.json
    skills/
      exp-mock-usage-analysis/
        SKILL.md
      exp-simd-vectorization/
        SKILL.md
      exp-test-maintainability/
        SKILL.md
    version.json
  dotnet-maui/
    .codex-plugin/
      plugin.json
    plugin.json
    skills/
      dotnet-maui-doctor/
        references/
          installation-commands-macos.md
          installation-commands-windows.md
          installation-commands.md
          microsoft-openjdk.md
... 1600 more

Showing a partial view of a very large repo.

FAQ

dotnet-skills is a Claude Code plugin with 96 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes csharp-scripts, dotnet-pinvoke, nuget-trusted-publishing. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.

What is dotnet-skills?: This repository contains the .NET team's curated set of core skills and custom agents for coding agents. For information about the Agent Skills standard, see agentskills.io. 📊 Dashboard - Accuracy and efficiency scoring trends for contained plugins (
How do I install dotnet-skills?: Run these in Claude Code: /plugin marketplace add dotnet/skills. Then prompt normally.
Does dotnet-skills auto-invoke its skills?: Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
Is dotnet-skills free?: Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.