dotnet/skills
107 skills57.4k installs529k starsGitHub
Install
npx skills add https://github.com/dotnet/skillsSkills in this repo
1Analyzing Dotnet PerformanceThe analyzing-dotnet-performance skill >- # .NET Performance Patterns Scan C#/.NET code for performance anti-patterns and produce prioritized findings with concrete fixes. Patterns sourced from the official .NET performance blog series, distilled to customer-actionable guidance. ## When to Use - Reviewing C#/.NET code for performance optimization opportunities - Auditing hot paths for allocation-heavy or inefficient patterns - Systematic scan of a codebase for known anti-patterns before release - Second-opinion analysis after manual performance review ## When Not to Use - **Algorithmic complexity analysis** - this skill targets API usage patterns, not algorithm design - **Code not on a hot path** with no performance requirements - avoid premature optimization ## Inputs | Input | Required | Description | |-------|----------|-------------| | Source code | Yes | C# files, code blocks, or repository paths to scan | | Hot-path context | Recommended | Which code paths are performance-critical | | Target framework | Recommended | .NET version (some patterns require .NET 8+) | | Scan depth | Optional | `critical-only`, `standard` (default), or `comprehensive` | ## Workflow ### Step 1:.1.5kinstalls2Optimizing Ef Core Queriesoptimizing-ef-core-queries is an MIT-licensed skill from dotnet/skills that walks developers through Entity Framework Core performance fixes including N+1 detection, correct tracking modes, compiled queries, and common ORM traps that bloat SQL and spike database CPU or IO. The skill applies when LINQ queries generate too many statements, large result sets cause memory pressure, or logs reveal repeated round-trips. It explicitly excludes Dapper, raw ADO.NET, and pure index-tuning problems that are database-side rather than ORM-side. Reach for optimizing-ef-core-queries when EF Core is the data layer and application queries—not missing indexes alone—are the bottleneck.1.4kinstalls3Run Testsrun-tests is an official dotnet/skills agent skill for correctly executing and debugging `dotnet test` across modern .NET projects. The skill auto-detects whether a solution uses VSTest or Microsoft.Testing.Platform, identifies MSTest, xUnit, NUnit, or TUnit frameworks, and selects the right filter flags, `--` separator rules for .NET SDK 8/9 versus 10+, and TRX report options. Reach for run-tests when running all tests in a solution, filtering by class or trait, targeting a single TFM with `--framework`, collecting crash dumps, or diagnosing mixed-argument failures. It prevents the common mistake of blending incompatible VSTest and Microsoft.Testing.Platform CLI arguments.1.4kinstalls4Csharp Scriptscsharp-scripts is a .NET-focused agent skill for running file-based C# applications with dotnet run instead of scaffolding a csproj solution. The skill covers single-file scripts, multi-file apps composed with #:include and #:exclude, and linked assemblies via #:ref when a developer explicitly wants C# without project boilerplate. Agents use it to prototype logic, validate API behavior, and iterate on small utilities before integrating code into larger applications. csharp-scripts deliberately excludes language-agnostic throwaway scripts, Python-style automation, and changes inside existing app codebases. Reach for csharp-scripts when the goal is a fast C# experiment on disk, not a production service layout.1.2kinstalls5Test Anti PatternsTest-anti-patterns is an audit skill from the official dotnet/skills collection that reviews existing test files or suites in any supported language for quality smells. It flags tests that pass but verify nothing, missing assertions, swallowed exceptions, tautological self-comparisons, coverage-touching tests, overly broad exception catches, and flaky patterns involving Thread.Sleep, DateTime.Now, or shared mutable state. It also detects duplicated tests and magic values. The skill outputs a severity-ranked report labeled Critical, Warning, or Info with actionable fixes. Supported stacks include .NET, Python with pytest, TypeScript with Jest, Java, Go, Ruby, and C++. Test-anti-patterns explicitly does not write new tests, run test commands, or compute coverage metrics—use companion skills for those tasks. Developers invoke it during code review or pre-merge audits when a suite looks green but untrustworthy.1.2kinstalls6Msbuild Antipatternsmsbuild-antipatterns is a dotnet/skills plugin skill that catalogs MSBuild anti-patterns with symptoms, explanations, and concrete BAD→GOOD transformations for .csproj, .vbproj, .fsproj, .props, .targets, and .proj files. Documented entries span AP-1 through AP-22, including AP-16 for using Exec instead of property functions for string manipulation and AP-22 for MSBuild task forks that cause duplicate builds and parallel-write races. The skill activates only in MSBuild/.NET build contexts and explicitly excludes npm, Maven, or CMake projects. Developers reach for msbuild-antipatterns when reviewing SDK-style projects, cleaning CI build scripts, or replacing shell-dependent Exec tasks with cross-platform MSBuild property functions.1.1kinstalls7Msbuild Modernizationmsbuild-modernization is an official dotnet/skills guide for migrating legacy MSBuild projects to clean SDK-style format. The skill covers converting verbose .csproj and .vbproj XML, migrating packages.config to PackageReference, removing Properties/AssemblyInfo.cs in favor of auto-generation, eliminating explicit `<Compile Include>` lists via implicit globbing, and consolidating shared settings into Directory.Build.props. Legacy indicators include the ToolsVersion attribute, `<Import Project="$(MSBuildToolsPath)">`, and simple .csproj files exceeding 50 lines. Developers reach for msbuild-modernization when upgrading .NET Framework or early SDK hybrids, not for projects already SDK-style or non-.NET systems like npm, Maven, or CMake.1.1kinstalls8Dotnet Trace Collectdotnet-trace-collect is a Claude Code skill for collecting production-safe diagnostics from modern .NET services via dotnet-monitor and related trace tools. The skill covers dotnet-monitor as a REST API diagnostics collector designed for container and Kubernetes sidecar deployments on Windows, Linux, and macOS, requiring .NET Core 3.1 or later with no admin privileges. Installation paths include the global dotnet tool and the mcr.microsoft.com/dotnet/monitor container image. Developers reach for dotnet-trace-collect when a running .NET API shows latency spikes, memory pressure, or CPU bottlenecks and they need traces without restarting the process.1.1kinstalls9Directory Build Organizationdirectory-build-organization is a .NET skill from dotnet/skills that teaches Common Directory.Build patterns for MSBuild solutions. It shows conditional PropertyGroup blocks in Directory.Build.props that detect test projects by naming conventions like .Tests and .UnitTests, setting IsPackable false and IsTestProject true. Directory.Build.targets applies rules after SDK evaluation—such as SelfContained false for Exe OutputType and GenerateDocumentationFile for libraries excluding tests. Developers reach for directory-build-organization when scaling solutions beyond a handful of .csproj files and needing centralized build validation, output layout, and post-build consistency.1kinstalls10Code Testing Agentcode-testing-agent is a .NET-focused agent skill from dotnet/skills that spins up a repeatable workflow to author unit and integration tests, execute them against recently changed assemblies, and iterate on failures until coverage improves. The skill is built for C# teams using standard .NET test runners who want agents to propose realistic test cases tied to diffs instead of hand-writing every assertion. Developers reach for code-testing-agent when a feature branch lands without adequate xUnit or NUnit coverage, when refactors need regression guards, or when integration scenarios around APIs and services must be validated before merge. The workflow accelerates test authoring during active development by coupling generation, execution, and refinement in one agent loop rather than treating each step as a separate manual task.981installs11Dotnet Aot Compatdotnet-aot-compat is an official skill from dotnet/skills with 502 installs on skills.sh. It scans .NET projects for patterns that break Native AOT—reflection, trimming-unfriendly APIs, dynamic code, and incompatible package references—and suggests or applies fixes before publish. Developers reach for it when enabling PublishAot or preparing console, worker, or minimal API apps for trimmed native binaries. The skill fits pre-release hardening rather than everyday feature development. Pair it with AOT publish workflows when build failures or trim warnings block shipping self-contained executables.939installs12Configuring Opentelemetry Dotnetconfiguring-opentelemetry-dotnet is an MIT-licensed skill from dotnet/skills for configuring OpenTelemetry distributed tracing, metrics, and logging in ASP.NET Core using the .NET OpenTelemetry SDK. It covers OTLP as the primary export protocol, Jaeger OTLP-native ingestion, Prometheus OTLP ingestion with explicit opt-in, custom business metrics and trace spans, and troubleshooting distributed trace context propagation. Developers reach for it when adding observability to .NET services, setting up exporters, or fixing broken trace correlation across microservices.877installs13Technology Selectiontechnology-selection is a Microsoft-aligned .NET skill from dotnet/skills that maps AI feature requirements to concrete libraries: ML.NET for classic ML, Microsoft.Extensions.AI for LLM orchestration, Microsoft Agent Framework for agentic workflows, GitHub Copilot SDK for extensions, ONNX Runtime for custom inference, and OllamaSharp for local models. The skill covers classification, regression, clustering, anomaly detection, recommendation, RAG with vector search, tool-calling agents, and summarization paths for .NET 8+ applications. Developers reach for technology-selection when adding intelligence to a .NET service and needing a justified stack choice instead of defaulting to a single SDK. It explicitly excludes non-.NET project targets.767installs14Create Skillcreate-skill is a dotnet/skills agent skill that scaffolds new skills conforming to the Agent Skills specification and dotnet/skills repository conventions. It generates SKILL.md frontmatter, section templates, optional script folders, and validation guidance so agents follow repeatable workflows instead of improvising instructions each session. Developers use create-skill when adding a new skill from scratch, setting up directory structure, or ensuring compliance with agentskills.io rules. The skill explicitly covers when not to modify existing skills, keeping scope focused on greenfield skill authoring for Claude Code and compatible agents.759installs15Dotnet Pinvokedotnet-pinvoke is a Claude Code skill from dotnet/skills, ranked third on skills.sh with 437 installs, for calling native Windows and C libraries from .NET. It guides developers through P/Invoke declarations, struct marshalling, string and pointer handling, calling conventions, and common interop pitfalls that cause runtime crashes or memory corruption. The skill targets scenarios where managed C# or F# code must wrap existing native DLLs, platform APIs, or legacy C libraries. Developers reach for dotnet-pinvoke when adding native dependencies to a .NET service, desktop tool, or library and manual DllImport boilerplate is error-prone.752installs16Migrate Dotnet10 To Dotnet11migrate-dotnet10-to-dotnet11 is a dotnet/skills entry ranked 21 on Skills.sh with 435 installs that guides automated migration from .NET 10 to .NET 11. The skill applies the required project-file target framework updates, package version bumps, and breaking-change fixes so a solution builds cleanly on the newer SDK without manual checklist hunting. Developers reach for migrate-dotnet10-to-dotnet11 when a repository still targets net10.0 and CI, local builds, or deployment pipelines must move to .NET 11 before shipping security patches or framework features. The workflow emphasizes safe, systematic updates across csproj files, dependencies, and compiler-facing API changes rather than piecemeal edits that leave hidden build failures.750installs17Migrate Dotnet9 To Dotnet10migrate-dotnet9-to-dotnet10 is a skill from dotnet/skills that guides agents through upgrading .NET 9 projects to .NET 10 by updating project files, configuration, and package dependencies. The skill ranks 16 on skills.sh and reports 447 installs, making it a commonly used reference for .NET version migrations. Developers reach for migrate-dotnet9-to-dotnet10 when retargeting APIs, services, or libraries to the next LTS-aligned runtime without hand-editing every csproj and appsettings file. It focuses on automated, incremental changes across the solution rather than greenfield scaffolding.749installs18Build Perf Diagnosticsbuild-perf-diagnostics is a .NET agent skill for MSBuild binary log (binlog) performance analysis. It interprets timeline data and Target/Task Performance Summaries to flag seven common bottleneck categories, including ResolveAssemblyReference over 5 seconds, Roslyn analyzers consuming more than 30% of Csc time, single targets dominating over 50% of build time, node utilization below 80%, excessive Copy tasks, and NuGet restore on every build. Use it after build-perf-baseline has established measurements. Developers reach for it when .NET builds regress in CI or locally and need evidence-backed root cause, not guesswork.744installs19Build Parallelismbuild-parallelism is a .NET MSBuild optimization skill from dotnet/skills for multi-project solutions that build sequentially despite available cores. MSBuild defaults /maxcpucount to 1, so the skill instructs developers to pass -m for parallel builds and evaluate /graph mode for better scheduling and isolation. Coverage includes BuildInParallel on MSBuild tasks, trimming unnecessary ProjectReferences, and solution filters (.slnf) to compile subsets. Developers reach for build-parallelism when build times stall on large solutions, -m shows no improvement, or dependency topology blocks parallelism. The skill explicitly excludes single-project builds and incremental compilation issues handled by sibling skills.736installs20Dotnet Maui Doctordotnet-maui-doctor is a diagnostic and repair skill from dotnet/skills that automatically identifies and fixes configuration, SDK, and dependency problems in .NET MAUI projects. Developers reach for it when MAUI builds fail due to mismatched workloads, missing SDK components, or broken package references instead of manually tracing MSBuild errors. On skills.sh the skill ranks 4 with 432 installs, making it one of the most adopted entries in the dotnet/skills catalog. The skill targets cross-platform mobile developers using .NET MAUI who need fast remediation of environment and project-file issues before continuing UI work.733installs21Migrate Nullable Referencesmigrate-nullable-references is an official dotnet/skills package with 441 installs and skills.sh rank 17 that guides agents through enabling nullable reference types in C# solutions. The skill helps plan compiler warning fixes, add nullability annotations, and update thousands of lines across projects without breaking builds. Developers reach for migrate-nullable-references when upgrading .NET SDK settings, clearing CS86xx warnings, or standardizing null contracts before shipping safer APIs and libraries.733installs22Build Perf Baselinebuild-perf-baseline is an MIT-licensed skill in dotnet/skills for establishing build performance baselines and applying optimization techniques on MSBuild-based .NET solutions. It guides before-and-after measurements across cold, warm, and no-op build scenarios, then recommends strategies such as MSBuild Server, static graph builds, artifacts output layout, and dependency graph trimming. The skill explicitly starts here before build-perf-diagnostics, incremental-build, or build-parallelism skills when investigating slow compiles. It excludes non-MSBuild build systems and defers detailed bottleneck analysis to build-perf-diagnostics after baselines exist. Developers reach for build-perf-baseline when CI or local dotnet build times regress and they need reproducible timing evidence before changing project structure or analyzer settings.732installs23Dump Collectdump-collect is a diagnostics skill in the official dotnet/skills catalog with 423 installs on skills.sh. It helps developers capture comprehensive runtime state from .NET applications and services when incidents occur in production or during local debugging. The skill streamlines collecting dumps, logs, and related diagnostic artifacts so engineers can analyze failures without improvising manual collection steps. Reach for dump-collect when a .NET app crashes, hangs, or misbehaves and you need a complete evidence bundle before root-cause analysis.732installs24Binlog Failure Analysisbinlog-failure-analysis is a Microsoft-maintained .NET skill for diagnosing MSBuild build failures from existing binary log (.binlog) files. The preferred path uses the binlog MCP server (Microsoft.AITools.BinlogMcp) exposed under the binlog MCP namespace bundled with the skill. Use it when console output is insufficient, cascading failures span multi-project builds, or MSBuild target execution order must be traced. The skill does not generate binlogs—use binlog-generation for that—and excludes non-MSBuild build systems. Developers reach for it during CI failures or local builds where error messages hide root causes deep in target chains.730installs25Microbenchmarkingmicrobenchmarking is an agent skill from dotnet/skills focused on BenchmarkDotNet microbenchmark authoring for performance-sensitive .NET and C# code paths. The skill guides developers through measuring allocations, latency, and performance regressions on hot paths before shipping features where microseconds matter. Developers reach for microbenchmarking when optimizing backend services, libraries, or framework internals that need evidence-backed performance data rather than intuition. Output includes benchmark projects, baseline measurements, and comparison results suitable for CI regression gates.730installs26Eval Performanceeval-performance is a dotnet/skills guide for developers fighting slow MSBuild evaluation—the phase before any compiler work runs. The skill applies when binlogs show high evaluation time, expensive glob patterns traverse large folders like node_modules or .git, import chains exceed twenty levels, preprocessed `/pp` output grows past ten thousand lines, or property functions perform file I/O such as `$([System.IO.File]::ReadAllText(...))`. It walks the five MSBuild evaluation phases, recommends `DefaultItemExcludes` glob tuning, and uses import-chain analysis via `/pp` preprocessing. Do not use eval-performance for compile-time slowness; that belongs to build-perf-diagnostics. Reach for it when `dotnet build` hangs in the evaluation phase on large SDK-style or multi-import solutions.727installs27Crap Scorecrap-score is a MIT-licensed skill from dotnet/skills that calculates Change Risk Anti-Patterns (CRAP) scores for targeted .NET methods, classes, or single source files. It merges cyclomatic complexity with Cobertura coverage data using the formula CRAP(m) = comp(m)² × (1 − cov(m))³ + comp(m), surfacing methods that are both complex and undertested. Developers invoke crap-score when explicitly asked to compute CRAP scores or assess risky untested code for a specific target—not for project-wide coverage plateaus or writing tests without CRAP context (those belong to coverage-analysis). With 491 installs on skills.sh from a 3.6K-star repository, crap-score gives engineers a single metric to rank refactor and test-addition candidates before merges. The skill scopes analysis to explicit targets rather than whole-solution coverage dashboards, making it ideal for focused code review and hot-spot triage in C# codebases.716installs28Incremental Buildincremental-build is a .NET-focused agent skill for diagnosing and fixing MSBuild incremental build regressions in large solutions and CI pipelines. It walks through eight documented failure modes—missing Inputs/Outputs on custom targets, volatile properties in output paths, untracked file writes, missing FileWrites registration, glob churn, and Visual Studio Fast Up-to-Date Check issues—and teaches reading binlog lines like 'Building target completely' versus 'Skipping target'. Developers reach for incremental-build when subsequent builds rebuild despite no meaningful source changes, or when no-op builds fail. It is not for first-time build slowness or parallelism tuning, which belong to separate build-perf workflows.714installs29Migrate Dotnet8 To Dotnet9migrate-dotnet8-to-dotnet9 is an official-style skill in the dotnet/skills repository for moving solutions from .NET 8 to .NET 9. It walks developers through retargeting Target Framework Monikers in csproj files, bumping NuGet dependencies to .NET 9-compatible versions, and addressing breaking API or ASP.NET Core hosting changes surfaced during build and test runs. The skill emphasizes a repeatable checklist so upgrades stay consistent across multi-project repos. Teams invoke it during LTS migration windows, before deploying to .NET 9 runtimes, or when CI starts failing on outdated package pins after installing the .NET 9 SDK. It targets migration mechanics rather than new feature design.711installs30Binlog Generationbinlog-generation is a Claude Code skill from dotnet/skills for producing MSBuild binary logs during .NET SDK commands. The skill shows how to pass /bl:{} to dotnet build, test, pack, publish, and restore so every target, task, and compiler event is recorded for post-build investigation. It requires MSBuild 17.8+ and .NET 8 SDK or newer for the {} placeholder, with PowerShell using -bl:{{}}. Developers reach for binlog-generation before binlog-failure-analysis or build-perf-diagnostics when local or CI builds fail intermittently, run slowly, or need a reproducible execution trace.709installs31Nuget Trusted Publishingnuget-trusted-publishing is a dotnet/skills guide ranked 29 on skills.sh with 415 catalog installs that sets up NuGet trusted publishing on GitHub Actions repositories. It replaces long-lived secrets.NUGET_API_KEY values with OIDC short-lived tokens via NuGet/login@v1 and the id-token: write permission, eliminating secrets to rotate or leak. Prerequisites include a GitHub Actions workflow, a nuget.org account able to create trusted publishing policies, and packages such as dotnet tools, MCP servers, or templates. The skill covers migrating existing publish workflows, creating new keyless pipelines from scratch, and answering NuGet/login@v1 setup questions. Developers reach for nuget-trusted-publishing when shipping NuGet packages from CI and auditors or supply-chain policies require removing static API keys from repository secrets during dotnet release automation.703installs32Writing Mstest Testswriting-mstest-tests is an agent skill from dotnet/skills focused on creating and fixing MSTest unit and integration tests for .NET services. It targets MSTest 3.x and 4.x APIs, replacing brittle Assert.IsTrue patterns with expressive assertions such as Contains, ContainsSingle, HasCount, IsEmpty, IsNotEmpty, DoesNotContain, AreSame, IsNull, StartsWith, EndsWith, MatchesRegex, IsGreaterThan, IsLessThan, and IsInRange. The skill modernizes legacy ExpectedException usage to Assert.Throws, fixes swapped Assert.AreEqual arguments, and supports data-driven tests with DataRow, DynamicData, and ValueTuples plus lifecycle hooks like TestInitialize, TestCleanup, and TestContext. Developers reach for writing-mstest-tests when adding new MSTest coverage, upgrading assertion style, or repairing flaky arrange-act-assert tests before merge.702installs33Coverage Analysiscoverage-analysis is a Microsoft dotnet agent skill for executing .NET test coverage tooling and reading the resulting reports. The skill helps developers find untested branches, classes, and methods that block merge requests, release candidates, or CI quality gates. Developers reach for coverage-analysis when dotnet test output exists but gaps remain unclear across assemblies or conditional paths. It focuses on interpretation and actionable gaps rather than writing production features. Use it when preparing PRs, release branches, or enforcing minimum coverage thresholds in .NET solutions.695installs34Check Bin Obj Clashcheck-bin-obj-clash is a .NET agent skill from dotnet/skills that detects MSBuild projects writing to the same bin or obj directories. The skill finds shared OutputPath or IntermediateOutputPath collisions, missing AppendTargetFrameworkToOutputPath settings, and extra global properties such as PublishReadyToRun that cause redundant evaluations and project.assets.json conflicts. Developers reach for check-bin-obj-clash when builds fail with file-already-exists errors, locked-file retries, or missing outputs in multi-project and multi-targeting solutions. It diagnoses configuration clashes rather than generic file locks, making it valuable before CI hardening or large solution refactors.694installs35Resolve Project Referencesresolve-project-references is an MIT-licensed skill from dotnet/skills that prevents misguided MSBuild optimizations when ResolveProjectReferences appears as the most expensive target in performance summaries. The reported duration largely reflects waiting for dependent projects to build, not CPU spent inside the target itself, so tuning ResolveProjectReferences directly often wastes effort. Developers activate this skill when that target tops the log and need guidance to focus on actual task self-time hotspots. For general build performance outside this specific misleading metric, the skill points to build-perf-diagnostics instead of acting as a catch-all optimizer.691installs36Including Generated Filesincluding-generated-files is a dotnet/skills recipe for fixing MSBuild targets that generate files during build but leave those files missing from compilation or publish output. It covers CS0246 errors for types that should exist, custom build tasks whose outputs are invisible to later targets, globs that expand at evaluation time before execution creates files, and Clean-target hygiene for generated artifacts. The skill documents correct BeforeTargets timing against CoreCompile, BeforeBuild, and AssignTargetPaths, adding outputs to Compile and FileWrites item groups, and using $(IntermediateOutputPath) instead of hardcoded obj/ paths. .NET developers reach for including-generated-files when source generators, protobuf, or custom codegen steps produce files that the compiler or IDE never sees.689installs37Convert To Cpmconvert-to-cpm is a Microsoft dotnet/skills agent workflow that converts .NET solutions (.sln, .slnx) and projects (.csproj, .fsproj, .vbproj) from scattered PackageReference Version attributes to NuGet Central Package Management using Directory.Packages.props. The skill runs a 9-step procedure: scope detection, baseline build capture with binlog and JSON package lists, CPM audit, conflict resolution with user confirmation, Directory.Packages.props creation (including dotnet new packagesprops on .NET 8+), project file updates, MSBuild property inlining, restore/build validation, and a structured convert-to-cpm.md report. It bundles 5 reference guides covering audit complexities, baseline comparison, MSBuild property handling, and NuGet error codes. Reach for convert-to-cpm when package versions drift across projects, when aligning NuGet bumps repo-wide, or when adopting CPM for the first time—after all projects use PackageReference, not packages.config.688installs38Clr Activation Debuggingclr-activation-debugging is a skill in dotnet/skills focused on diagnosing why the Common Language Runtime fails to activate a .NET application on a host. Developers use it when apps exit immediately with missing runtime messages, mismatched fx.json configuration, or framework resolution errors across deployed servers and developer workstations. The skill fits sessions where published binaries work on one machine but fail on another due to SDK versus runtime confusion, roll-forward settings, or multi-targeting issues. Reach for clr-activation-debugging before rewriting application code when the failure is clearly at host startup and runtime discovery rather than in-business logic exceptions.685installs39Create Custom Agentcreate-custom-agent is a dotnet/skills agent skill for scaffolding VS Code custom agent files that define specialized AI personas. It walks through creating agents/<agent-name>.agent.md with YAML frontmatter for description, tools, agents, model, handoffs, user-invokable flags, and mcp-servers for GitHub Copilot targets. The workflow covers read-only versus full-editing tool patterns, handoff buttons with label, agent, prompt, send, and model fields, Markdown instruction bodies, and validation via the Chat diagnostics view. Included templates demonstrate planner and code-reviewer agents with explicit constraints such as no code changes for planners. Developers reach for create-custom-agent when introducing new repository agents, restricting tools for security reviewers, or wiring multi-step handoffs between planner and implementation personas.684installs40Msbuild Servermsbuild-server is a .NET & C# skill from dotnet/skills that explains how MSBuild Server improves command-line build performance for .NET projects. The skill activates when dotnet build incremental compiles are noticeably slower than Visual Studio and walks through setting MSBUILDUSESERVER=1 to keep a persistent server that caches MSBuild evaluation across CLI invocations. Developers reach for msbuild-server in local dev shells and CI jobs where small code changes still trigger full re-evaluation without a long-lived MSBuild process. The readme explicitly excludes IDE-based Visual Studio builds because Visual Studio already runs a persistent MSBuild host.682installs41Minimal Api File Uploadminimal-api-file-upload is a Microsoft dotnet agent skill for implementing file upload endpoints in ASP.NET Core Minimal APIs on .NET 8 and later. The skill covers IFormFile and IFormFileCollection parameters, size limits, content type validation, and streaming patterns for large uploads. Developers reach for minimal-api-file-upload when products need multipart endpoints with storage hooks but want to avoid MVC controller boilerplate. The readme notes that files over 1GB should use MultipartReader streaming instead of simple IFormFile binding. Use it for secure upload routes with validation, not JSON-only APIs.672installs42Thread Abort Migrationthread-abort-migration is a .NET & C# skill from dotnet/skills for modernizing code that relied on Thread.Abort, ThreadAbortException, Thread.ResetAbort, or Thread.Interrupt for forced thread termination. The skill covers migrating ASP.NET Response.End and Response.Redirect(url, true) patterns that internally invoked Thread.Abort, and resolves PlatformNotSupportedException or SYSLIB0006 after retargeting to .NET 6+. Developers reach for thread-abort-migration when legacy Framework services fail on modern runtimes and need cooperative cancellation instead of abrupt thread kills. The readme excludes code using only Thread.Join, Thread.Sleep, or Thread.Start without abort semantics because those APIs remain unchanged.671installs43Dotnet Webapidotnet-webapi is a Microsoft-maintained agent skill for scaffolding and extending ASP.NET Core Web API endpoints with production-ready HTTP semantics. The skill covers controller and minimal API patterns, routing, middleware, request validation, JSON contracts, OpenAPI/Swagger documentation, global error-handling middleware, and .http test files. Developers reach for dotnet-webapi when adding new API endpoints, wiring Swagger metadata, or setting up consistent error responses—not for EF Core query optimization, Blazor frontend, gRPC, or SignalR work. The skill produces well-structured endpoints with proper status codes and documented contracts. Use dotnet-webapi during backend build when shipping HTTP services that need OpenAPI-documented, testable API surfaces.669installs44Mtp Hot Reloadmtp-hot-reload is a dotnet/skills workflow for Microsoft Testing Platform (MTP) hot reload during iterative test fixing. The skill walks through a 6-step process: verify the project uses MTP instead of VSTest, install the Microsoft.Testing.Extensions.HotReload NuGet package, enable TESTINGPLATFORM_HOTRELOAD_ENABLED=1 via shell or launchSettings.json, run dotnet run --project for console-mode hot reload, edit failing test or production code while the host stays alive, and finish with a full dotnet test clean build. It documents framework-specific filter syntax for MSTest, NUnit, xUnit v3, and TUnit. Developers reach for mtp-hot-reload when one or more tests fail and rebuild overhead slows the fix loop, but not for writing tests from scratch or CI pipeline configuration.665installs45Template Discoverytemplate-discovery from dotnet/skills helps agents find, inspect, and compare .NET project templates before any project is created. It resolves natural-language descriptions—such as a web API with authentication—into ranked template matches with pre-filled parameters, so teams avoid guessing package IDs or mis-scaffolding solutions. The skill supports comparing templates side by side, inspecting parameters and constraints, and understanding what a template produces prior to running dotnet new. It explicitly does not create projects (use template-instantiation), author custom templates (use template-authoring), or perform deep pairwise comparison (use template-comparison). Developers reach for template-discovery at the planning moment between intent and repo creation when multiple official and community starters could fit. Output is actionable template identity plus parameter guidance ready for the next instantiation step.654installs46Template Instantiationtemplate-instantiation is a dotnet/skills plugin skill in the dotnet-template-engine collection that creates .NET projects using dotnet new with validated parameters, smart defaults, and post-create verification. After scaffolding, it detects Central Package Management by walking up for Directory.Packages.props, strips inline PackageReference Version attributes from generated csproj files, and merges PackageVersion entries into the central props file. The skill also resolves latest stable NuGet versions, composes multi-project solutions such as API plus tests plus libraries, and manages installing or uninstalling template packages via dotnet new install. It explicitly excludes template discovery comparisons and custom template authoring, which belong to sibling skills. Developers reach for template-instantiation when bootstrapping a runnable .NET solution that must honor existing repo conventions like CPM and global.json SDK pins. Install individual skills with the dotnet skill-installer CLI pointing at the GitHub skill path.647installs47Android Tombstone Symbolicationandroid-tombstone-symbolication is a .NET skills package skill for decoding Android native crash tombstones produced by .NET Android applications. When a .NET MAUI or .NET Android app crashes in native code, tombstone files contain raw addresses that are unreadable without symbolication. This skill walks developers through mapping those frames to function names and source locations using Android NDK symbol tooling and .NET Android debug artifacts. Reach for android-tombstone-symbolication after receiving tombstone crash reports from test devices or production crash pipelines when JNI or native interop is involved.634installs48Template Authoringtemplate-authoring is a .NET-focused agent skill for building reusable dotnet new scaffolds from existing projects. The skill walks through bootstrapping .template.config/template.json with identity, shortName, symbols, parameters, and post-actions, then validates template.json for schema compliance and parameter issues before packaging templates as NuGet packages for team distribution. Developers reach for template-authoring when internal starter solutions need consistent CLI scaffolding instead of copy-paste repos or hand-edited manifests. The skill explicitly defers template discovery and instantiation to companion skills, keeping scope on authoring and validation only.627installs49Create Skill Testcreate-skill-test is a Claude Code skill in dotnet/skills for scaffolding evaluation tests that guard agent skill behavior. It generates eval.yaml files with scenarios, assertions, rubrics, and organized fixture files following repository conventions and skill-validator requirements. The skill explicitly covers overfitting avoidance so tests prove general trigger behavior instead of memorizing one prompt wording. Developers use create-skill-test when adding a new skill to dotnet/skills, defining evaluation scenarios, or setting up fixture directories—not when running or debugging existing test suites or authoring SKILL.md content itself. Output aligns with skill-validator checks so CI can catch regressions when descriptions, triggers, or bundled resources change across Claude Code updates.625installs50Migrate Vstest To Mtpmigrate-vstest-to-mtp is a Claude Code skill in dotnet/skills for converting .NET solutions from VSTest to Microsoft Testing Platform (MTP). It updates project files, SDK references, runsettings, CI test commands, and adapter wiring for MSTest, NUnit, and xUnit.net v2 while explaining MTP behavioral differences such as exit code 8 on zero tests discovered and the --ignore-exit-code / TESTINGPLATFORM_EXITCODE_IGNORE escape hatches. The skill centralizes EnableMSTestRunner, EnableNUnitRunner, UseMicrosoftTestingPlatformRunner, and OutputType=Exe on test projects via Directory.Build.props using MSBuildProjectName rather than IsTestProject heuristics. Developers reach for migrate-vstest-to-mtp when enabling MTP runner, switching CI off VSTest, or debugging discovery failures after a platform migration.624installs51Detect Static DependenciesGuides detection and reasoning about static dependencies in .NET solutions so agents can evaluate trim, Native AOT, and single-file publish readiness, validate project references, and prevent silent runtime failures from removed or unreferenced assemblies.622installs52Filter Syntaxfilter-syntax is a MIT-licensed reference skill in dotnet/skills that catalogs test filter syntax across .NET platforms and frameworks. It documents VSTest --filter expressions for MSTest, xUnit v2, and NUnit on VSTest, and MTP filters for MSTest, NUnit, xUnit v3, and TUnit, including VSTest-to-MTP translation rules. The skill is user-invocable false and disable-model-invocation true—run-tests, mtp-hot-reload, and migrate-vstest-to-mtp load it automatically when filter strings are needed. Developers indirectly benefit when agents construct dotnet test --filter queries or migrate legacy VSTest filters to MTP. Reach for parent skills that execute tests rather than invoking filter-syntax directly.619installs53Maui App Lifecyclemaui-app-lifecycle is a Claude Code agent skill from the official dotnet/skills repository that guides developers and agents through correct .NET MAUI application lifecycle implementation across mobile and desktop targets. The skill covers handling resume and sleep transitions, backgrounding behavior, and platform-specific startup sequences on iOS, Android, Windows, and Mac so apps preserve state and respond cleanly to OS lifecycle events. Developers reach for maui-app-lifecycle when cross-platform MAUI apps lose state on background, mishandle cold start, or behave differently per platform because lifecycle hooks were wired incorrectly or omitted entirely. Agents apply patterns for App lifecycle events, window activation, and platform conditional startup logic that MAUI documentation spreads across multiple guides. maui-app-lifecycle reduces bugs where timers, network calls, or navigation stacks continue running after suspend or fail to restore after resume. Teams building production .NET MAUI clients benefit when agents must scaffold lifecycle-aware code that passes store review expectations for background resource usage on Apple and Google platforms.617installs54Migrate Mstest V1v2 To V3migrate-mstest-v1v2-to-v3 is a Claude Code skill from dotnet/skills that walks agents through upgrading MSTest v1 assembly references (Microsoft.VisualStudio.QualityTools.UnitTestFramework) and MSTest v2 NuGet packages (MSTest.TestFramework 1.x–2.x) to MSTest v3. It fixes common breakage: AreEqual/AreNotEqual assertion overload errors, DataRow constructor changes, and replacement of .testsettings with .runsettings including timeout behavior. Developers invoke it after package bumps when Azure DevOps or GitHub Actions test jobs fail. The skill preserves existing test coverage while modernizing runner and framework wiring.616installs55Migrate Mstest V3 To V4migrate-mstest-v3-to-v4 is an official dotnet/skills workflow for upgrading MSTest.TestFramework, MSTest.TestAdapter, or MSTest.Sdk from 3.x to 4.x—not binary compatible with v3 libraries. The skill documents a four-step migration: assess current packages and TFMs, bump to MSTest 4.1.0, resolve source breaking changes via a quick-lookup table, then address behavioral shifts like TreatDiscoveryWarningsAsErrors and MSTest.Sdk MTP mode without Microsoft.NET.Test.Sdk. Breaking fixes cover Execute to ExecuteAsync on custom TestMethodAttribute, ThrowsException to ThrowsExactly, ExpectedExceptionAttribute removal, TestContext.Properties Contains to ContainsKey, and dropped net6.0/net7.0 targets. The repo includes 15 test fixtures. Use migrate-mstest-v3-to-v4 when dotnet build fails immediately after MSTest 4 package updates.613installs56Platform Detectionplatform-detection is a reference-only skill in the dotnet/skills catalog that documents how companion agent skills determine a .NET test project's runner platform and unit-test framework before executing or migrating tests. The skill defines detection rules for VSTest versus Microsoft.Testing.Platform and for MSTest, xUnit, NUnit, or TUnit by reading global.json, .csproj, Directory.Build.props, and Directory.Packages.props in a fixed order. It is marked user-invocable: false and disable-model-invocation: true, so developers do not call it directly; run-tests, mtp-hot-reload, and migrate-vstest-to-mtp load its reference data when they need consistent framework detection. Reach for those parent skills when running dotnet test, enabling MTP hot reload, or migrating from VSTest to Microsoft.Testing.Platform in mixed-framework repositories. The skill ships under the MIT license from the official dotnet/skills repository.608installs57Code Testing Extensionscode-testing-extensions is a dotnet/skills plugin skill (MIT license, user-invocable false) that agents call to discover language-specific guidance files for the code-testing pipeline. It indexes 16 extension files: 11 base language references—dotnet.md, python.md, typescript.md, powershell.md, cpp.md, go.md, java.md, rust.md, ruby.md, swift.md, kotlin.md—and five concrete pipeline walkthroughs including dotnet-examples.md, python-examples.md, typescript-examples.md, go-examples.md, and java-examples.md. Each base file documents test markers, assertion APIs, sleep and skip patterns, integration markers, and common errors for frameworks like MSTest, xUnit, pytest, Vitest, Jest, cargo test, and JUnit 5. Agents read the target language file before writing tests and pair it with the matching -examples.md for end-to-end research-plan-generate-fix-report cycles. Install via dotnet/skills marketplace in VS Code Copilot with chat.plugins.marketplaces set to dotnet/skills. Reach for code-testing-extensions when code-testing-agent or dotnet-test skills need the correct language extension path—not for manual terminal-only test runs.607installs58Migrate Xunit To Xunit V3migrate-xunit-to-xunit-v3 is an MIT-licensed Claude Code skill from dotnet/skills for migrating .NET test projects from xUnit.net v2 to xUnit.net v3. The skill updates package references to xunit.v3.* packages, modernizes attributes and assertions, adjusts collection and fixture patterns, and aligns build targets so solutions compile cleanly and tests pass with the same results as before migration. It explicitly excludes cross-framework moves such as MSTest or NUnit to xUnit, and points VSTest-to-Microsoft.Testing.Platform migrations to migrate-vstest-to-mtp. Developers reach for it when upgrading xunit to xunit.v3 in CI pipelines or local test projects. Load migrate-vstest-to-mtp alongside this skill when xUnit v3 MTP filter syntax such as --filter-class or --filter-trait is required.602installs59Generate Testability Wrappersgenerate-testability-wrappers is an agent skill from dotnet/skills in the dotnet-test plugin for making static .NET dependencies testable. It maps six categories—time, filesystem, environment, network, console, and process—to strategies: built-in TimeProvider and IHttpClientFactory on modern .NET, System.IO.Abstractions with MockFileSystem for files, or minimal custom interfaces delegating to Environment, Console, or Process statics. The workflow generates interface plus default implementation files, AddSingleton DI snippets, FakeTimeProvider test examples, and AsyncLocal ambient context alternatives when DI is unavailable. It wraps only detected call sites, not entire static surfaces. Use after detect-static-dependencies when DateTime.Now, File.ReadAllText, or Environment calls block meaningful unit tests.588installs60Template Validationtemplate-validation is a Microsoft dotnet/skills agent skill that encodes validation rules for custom dotnet new templates before NuGet publish or local install. It reviews .template.config/template.json for missing identity, name, or shortName fields, parameter type mismatches, shortName collisions with dotnet new subcommands like install or list, and misconfigured post-actions or constraints that cause templates to fail silently. Developers reach for template-validation when a template does not appear in dotnet new list, produces broken projects, or needs CI gating alongside template-authoring and template-instantiation skills in the dotnet-template-engine plugin. The skill references the official dotnet/templating wiki for template.json schema, symbol generators, post-action registry, and constraint types.588installs61Migrate Static To Wrappermigrate-static-to-wrapper is a .NET & C# skill in dotnet/skills that mechanically converts static dependency call sites into injectable abstractions across a file, project, or namespace. The workflow performs codemod-style replacements such as DateTime.UtcNow to TimeProvider.GetUtcNow(), File.ReadAllText to IFileSystem, and similar static-to-interface migrations, then adds constructor injection parameters and updates DI registration in ASP.NET Core or class libraries. Developers reach for this skill when legacy static helpers block unit testing or when modern .NET time and filesystem abstractions must be adopted consistently. Catalog data shows 293 installs. Use it for scoped mechanical migrations rather than one-off manual wrapper edits.549installs62Assertion Qualityassertion-quality is a dotnet/skills checker that analyzes test code for assertion variety and meaning rather than generating new tests. It flags trivial Assert.IsNotNull or toBeTruthy-only checks, assertion-free tests, single-field obsession, missing negative assertions, absent state verification, and tautological self-referential patterns. The workflow is polyglot across .NET, Python, TypeScript/JavaScript, Java, Go, Ruby, Rust, Swift, Kotlin, PowerShell, and C++—requiring the paired test-analysis-extensions language file such as dotnet.md or python.md before classifying assertions. Developers reach for it when auditing whether suites verify structure, exceptions, state transitions, side effects, and invariants instead of one return value. Output is a metrics report revealing shallow coverage that line coverage alone hides. skills.sh lists 294 installs and the dotnet/skills repository has 3.6K GitHub stars. The skill defers writing new tests to code-testing-agent and mutation gap analysis to test-gap-analysis.548installs63Apple Crash Symbolicationapple-crash-symbolication is a dotnet/skills agent skill for resolving .NET MAUI and Mono native backtrace frames in Apple .ips crash logs on iOS, tvOS, Mac Catalyst, and macOS. It extracts Mach-O UUIDs and load addresses, matches dSYM bundles with dwarfdump, runs atos from Xcode, and auto-downloads missing .dwarf symbols from the Microsoft symbol server. The bundled Symbolicate-Crash.ps1 script automates parsing, dSYM lookup, symbol download, and symbolication with flags like -ParseOnly, -DsymSearchPaths, and -CrashingThreadOnly. Reach for apple-crash-symbolication when investigating EXC_CRASH, EXC_BAD_ACCESS, SIGABRT, or SIGSEGV frames in libcoreclr or libmonosgen-2.0. Skip it for pure Swift or Objective-C crashes without .NET components or Android tombstone files.530installs64Test Gap AnalysisProvides a structured .NET test gap analysis workflow that compares production code against existing MSTest, xUnit, or NUnit coverage, highlighting critical missing scenarios and actionable test additions before release.511installs65Test Smell DetectionHelps reviewers and authors identify .NET test smells such as shared state, overspecified mocks, async races, and weak assertions, then refactor toward isolated, fast tests that give trustworthy signal before production releases.504installs66Test TaggingTeaches consistent .NET test tagging and filtering so unit, integration, and slow tests can be selected in local runs and CI pipelines, improving feedback speed and release safety.494installs67System Text Json Net11Documents System.Text.Json practices for .NET 11 backends, including source-generated serializers, custom converters, naming and polymorphism options, and AOT-compatible patterns for high-throughput APIs and minimal latency.475installs68Fetch And Send DataCovers .NET patterns for fetching and sending HTTP data using HttpClient, factory registration, authentication headers, serialization, cancellation, and resilient calls so agents integrate external APIs and backend services correctly.423installs69Configure AuthProvides guidance for implementing authentication and authorization in .NET web and API projects, including identity middleware, token validation, policy-based authorization, and integration with external IdPs so applications authenticate users and enforce permissions consistently.394installs70Create Blazor ProjectA developer tool for AI integration and automation. This is a developer tool for building and integrating AI-powered features.383installs71Property PatternsTeaches idiomatic C# property patterns for .NET backends, helping developers design immutable records, required members, and pattern-friendly models that are safer to serialize, validate, and evolve in APIs and domain layers.382installs72Collect User InputProvides patterns to collect user input interactively during .NET-oriented workflows—validating responses, offering guided choices, and persisting answers for scaffolding, configuration, or planning steps.380installs73Author ComponentA Blazor component-authoring skill covering parameters, event callbacks, render-fragment slots, lifecycle methods, async patterns, and code-behind. A developer uses it to write or review non-JS-interop Blazor components correctly.377installs74Coordinate ComponentsExplains how to coordinate .NET Blazor UI components through clear parameter passing, event callbacks, cascading values, and lifecycle management so complex interfaces remain composable, testable, and free of implicit coupling between pages and shared widgets.376installs75Item ManagementHelps organize and track .NET-related work items: splitting migrations and MCP tasks into ordered issues, defining done criteria, and maintaining visibility so dotnet/skills changes land consistently without dropped test or doc steps.373installs76Extension PointsTeaches how to model .NET extension points: define interfaces, registration pipelines, options, and versioning so hosts expose safe hooks for authentication, storage, telemetry, or feature modules without tight coupling.371installs77Plan Ui ChangeGuides mapping a Blazor page's visual regions into a tree of focused, composable components with defined data flow. A developer uses it when building a multi-section Blazor page or dashboard before writing the components.371installs78Support PrerenderingExplains how Blazor prerendering runs lifecycle methods twice and how to persist state, disable prerendering, or exclude pages. A developer uses it when fixing prerender-to-interactive handoff bugs like duplicate loads or flicker.367installs79Target AuthoringA developer tool for AI integration and automation. This is a developer tool for building and integrating AI-powered features.367installs80Use Js InteropCovers calling JavaScript from Blazor and .NET from JavaScript with collocated .razor.js modules and correct IJSObjectReference disposal. A developer uses it when adding or fixing JS interop in Blazor components.362installs81Convert Blazor Server To WebappSkill for Blazor framework migration. Guides architectural changes from server-side rendering to modern patterns.356installs82Test Analysis ExtensionsProvides file paths to per-language reference files (dotnet, python, typescript, java) used by polyglot test analysis skills. A test-quality auditor agent uses it to fetch framework-specific lookup tables for assertion APIs and test markers.339installs83Grade TestsA polyglot test-grading skill that gives per-test feedback on a specified set of methods, designed to be posted as a PR comment. A developer uses it for per-test evaluation of new or modified tests rather than a suite-wide audit.317installs84Migrate Xunit To MstestA migration skill that converts xUnit tests and packages to MSTest v4, mapping Fact/Theory/InlineData to TestMethod/DataRow/DynamicData and Assert methods to their MSTest equivalents. A developer uses it to port a test suite while preserving parallelization behavior.296installs85Find Untested SourcesStatically parses C# files with the Roslyn syntax API to map sources to tests and rank files that have no referencing test. A developer uses it before writing new tests to pick the next untested file without running coverage.283installs86Template Smart DefaultsResolves cross-parameter interactions when scaffolding dotnet new projects, such as AOT implying a compatible framework or auth implying HTTPS. A developer uses it to fill related parameter gaps and explain why a default was chosen.268installs87Authoring Github WorkflowsTeaches the YAML-vs-Actions traps in workflow files, correct expression quoting, and validation with actionlint. A developer uses it when editing files under .github/workflows or debugging a run that fails with no jobs started.265installs88Template ComparisonInspects multiple dotnet new templates and renders a side-by-side comparison of parameters and feature support. A developer uses it when deciding between similar templates like webapi vs webapp or blazor vs blazorwasm.265installs89Maui CollectionviewGuides using CollectionView in .NET MAUI to display scrollable data with layouts, selection, grouping, empty views, and pull-to-refresh. A developer uses it when building data-bound list or grid UI in a MAUI app.1installs90Maui Data BindingGuides MAUI data binding using x:DataType compiled bindings, ObservableObject change notification, converters, and binding modes. A developer uses it when connecting MAUI UI controls to ViewModel properties.1installs91Maui Dependency InjectionGuides setting up DI in MAUI via builder.Services with Singleton/Transient/Scoped lifetimes, constructor injection, and platform-specific registrations. A developer uses it when registering services, ViewModels, and Pages in a MAUI app.1installs92Maui Safe AreaGuides the new cross-platform SafeAreaEdges API in .NET 10 MAUI for per-edge insets, edge-to-edge layouts, and keyboard avoidance across Android, iOS, and Mac Catalyst. A developer uses it when content overlaps system bars or when migrating from legacy iOS-only safe-area APIs.1installs93Maui Shell NavigationGuides MAUI Shell navigation including visual hierarchy, URI navigation with GoToAsync, parameter passing, and navigation guards. A developer uses it when setting up app navigation, tabs, or flyout menus in a MAUI app.1installs94Maui ThemingGuides adding light/dark mode and custom branded themes in MAUI using AppThemeBinding, ResourceDictionary theme switching, and runtime system-theme detection. A developer uses it when adding theme support or user theme preferences to a MAUI app.1installs95DotnetA collection of core.NET skills for handling common.NET coding tasks. Developers use it as a general-purpose assistant while writing day-to-day.NET code across a project.0installs96Dotnet11A.NET development skill covering new.NET 11 APIs and C# language features. Developers use it when writing or modernizing.NET code so they apply the latest framework capabilities idiomatically.0installs97Dotnet AiA.NET skill for AI and ML, spanning technology selection, LLM integration, agentic workflows, RAG pipelines, MCP, and classic ML with ML.NET. Developers use it when adding AI capabilities or building agents in a.NET application.0installs98Dotnet AspnetcoreA.NET development skill for ASP.NET Core web development, including middleware, endpoints, real-time communication, and API patterns. Developers use it when implementing the backend and HTTP API of an ASP.NET Core application.0installs99Dotnet BlazorA.NET development skill for Blazor, covering component authoring, interactivity, and web-application patterns. Developers use it when constructing the UI of a Blazor web app in C#.0installs100Dotnet DataA.NET skill for data access and Entity Framework related tasks. Developers use it when implementing the data layer of a.NET application — querying, mapping, and persisting data through EF.0installs101Dotnet DiagA.NET skill for performance investigations, debugging, and incident analysis on running applications. Developers use it to diagnose production issues and analyze incidents in a live.NET system.0installs102Dotnet MauiA.NET MAUI development skill covering environment setup, diagnostics, troubleshooting, navigation, data binding, dependency injection, layout, and theming. Developers use it when creating cross-platform mobile and desktop apps with.NET MAUI.0installs103Dotnet MsbuildA comprehensive MSBuild and.NET build skill covering failure diagnosis, performance optimization, code quality, and modernization. Developers use it to fix broken builds and speed up the.NET build pipeline before shipping.0installs104Dotnet NugetA.NET skill for NuGet and package management, covering dependency management and modernization. Developers use it to add, update, and tidy package references while developing a.NET project.0installs105Dotnet Template EngineA.NET development skill for the Template Engine, covering template discovery, project scaffolding, and authoring custom templates. Developers use it to bootstrap new.NET projects or create reusable project templates.0installs106Dotnet TestA.NET skill for running, diagnosing, and migrating tests, covering test execution, filtering, platform detection, and MSTest workflows. Developers use it to validate.NET code and keep the test suite green before shipping.0installs107Dotnet UpgradeA.NET skill for migrating and upgrading projects across framework versions, language features, and compatibility targets. Developers use it to modernize an existing.NET codebase and move it onto newer runtimes safely.0installs