.NET Agent Skills

Install

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

This is third-party code. Review the repository files before installing.

What it does

The .NET team's repository with 15 plugins for coding agents. The dotnet plugin adds the C# language server and general development skills, while others cover specific areas: performance diagnostics, builds and MSBuild, NuGet package management, .NET version upgrades, test framework migration, Entity Framework, ASP.NET Core, Blazor, MAUI, AI and ML.NET, and new .NET 11 APIs. For example, analyzing-dotnet-performance scans for about 50 performance anti-patterns with tiered severity.

Who it is for. C# and .NET developers using Copilot, Claude Code, Cursor or Codex.

Example request

Scan the orders service for performance anti-patterns and sort findings by severity

Limitations

VS Code plugin support is a preview feature and may need to be enabled. Plugins install one at a time, and the skill list shows via /skills after a restart.

How to disable. Remove the installed plugin through the plugin menu in Copilot CLI, Claude Code or Codex.

Security check

• The dotnet plugin adds a C# language server
• Skills run builds, tests and diagnostic tools

README in short

A curated set of skills and agents from the .NET team following agentskills.io. A table lists 15 plugins with descriptions. Installation is covered for Copilot CLI and Claude Code, VS Code, Cursor and Codex CLI, including single skills via skill-installer. A public dashboard tracks skill value.

SKILL.md

---
name: analyzing-dotnet-performance
description: >-
  Scans .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 patterns.
license: MIT
---

# .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: Load Critical Reference

Resolve bundled paths from the directory that contains this `SKILL.md`, not from the user's workspace. Load this reference file first:

- `references/critical-patterns.md`

If a direct read fails, list this skill's `references/` directory once and retry only when the listing shows the expected file. Do not use workspace file or text search to locate the skill installation.

### Step 2: Detect Code Signals and Select Topic Recipes

Scan the code for signals that indicate which pattern categories to check. Use the `## Detection` section from the critical reference when available and the inline recipes in Step 3 for initial signal detection.

After detecting signals, load only the topic-specific references selected by scan depth:

- `critical-only`: No additional references (use only `critical-patterns.md`)
- `standard` (default): Load references matching detected signals from this list:
  - `references/async-patterns.md` — async/Task/ValueTask signals
  - `references/memory-and-strings.md` — Span/Memory/string allocation signals
  - `references/regex-patterns.md` — Regex signals
  - `references/collections-and-linq.md` — Dictionary/List/LINQ signals
  - `references/io-and-serialization.md` — JsonSerializer/HttpClient/Stream signals
  - `references/structural-patterns.md` — always loaded (unsealed classes checked regardless)
- `comprehensive`: Load all six topic-specific references above

Related