dotnet-skills: 30 .NET skills and specialist agents for Claude Code, Codex and Copilot

A plugin that trades on named .NET skills rather than general prompting

The repository is a collection of skills and agent personas for .NET work, packaged so that an AI coding assistant can load them on demand. The README describes the project as 30 skills and 5 specialized agents covering C#, Akka.NET, Aspire, EF Core, testing and performance optimization. The mechanism is retrieval by name rather than a system prompt stuffed with rules. A skill is a directory holding a SKILL.md file with a frontmatter name field, and the assistant is told to consult dotnet-skills by name when a task matches, then implement the smallest change. The stated preference is explicit in the guidance the project hands you: prefer retrieval-led reasoning over pretraining for any .NET work. That is a debatable premise, since it assumes the model would otherwise guess at .NET patterns rather than recall them, and it is worth noticing that the plugin is really a bet about which patterns a team considers non-negotiable. A team that has already written those rules into its own AGENTS.md may get more from a smaller internal set. The value here comes from specificity: routing by skill ID, with the same IDs used for the readable snippet, the compressed snippet and the individual SKILL.md files.

Installing into Claude Code and Codex through a plugin marketplace

Claude Code and Codex both install the plugin from a marketplace, and both paths are short. In the Claude Code CLI, the terminal app rather than the VSCode extension, you add this repository as a marketplace and then install the plugin by name.

/plugin marketplace add https://github.com/Aaronontheweb/dotnet-skills
/plugin install dotnet-skills

Updating later means refreshing the marketplace.

/plugin marketplace update

Codex takes the same shape with its own command syntax, and the README asks you to verify the result by listing installed plugins.

codex plugin marketplace add Aaronontheweb/dotnet-skills
codex plugin add dotnet-skills@dotnet-skills

codex plugin list

In both cases the skills are auto-discovered from the plugin's skills/ directory, and in the Codex CLI or IDE extension you invoke a skill with /skills or $skill-name. The Claude Code commands are slash commands entered in the running session, not shell commands, so pasting them into a terminal will fail. One boundary is worth stating early: the specialized agents are Claude Code specific and are not included in the Codex plugin. Codex users get the skills and nothing else, which changes how much of the advertised value they actually receive.

Copying skills into Copilot and OpenCode config directories

GitHub Copilot and OpenCode have no marketplace path here, so the installation is a file copy. For Copilot the README gives a project level install, which it marks as recommended, and a global install for all projects.

# Clone to .github/skills/ in your project
git clone https://github.com/Aaronontheweb/dotnet-skills.git /tmp/dotnet-skills
cp -r /tmp/dotnet-skills/skills/* .github/skills/

mkdir -p ~/.copilot/skills
cp -r /tmp/dotnet-skills/skills/* ~/.copilot/skills/

The OpenCode route is a shell loop, because OpenCode matches a skill directory name against the name field in the frontmatter of its SKILL.md file, and the script derives the directory name from the frontmatter before copying.

git clone https://github.com/Aaronontheweb/dotnet-skills.git /tmp/dotnet-skills

# Global installation (directory names must match frontmatter 'name' field)
mkdir -p ~/.config/opencode/skills ~/.config/opencode/agents
for skill_file in /tmp/dotnet-skills/skills/*/SKILL.md; do
  skill_name=$(grep -m1 "^name:" "$skill_file" | sed 's/name: *//')
  mkdir -p ~/.config/opencode/skills/$skill_name
  cp "$skill_file" ~/.config/opencode/skills/$skill_name/SKILL.md
done
cp /tmp/dotnet-skills/agents/*.md ~/.config/opencode/agents/

That loop is the real complexity of the OpenCode install: if you copy skills by hand and the folder name does not match the frontmatter name, the skill will not resolve. The same install also copies the agent markdown files into the agents directory, which is how the OpenCode setup gets the personas that the Codex plugin leaves out. The trade-off is that manual copies are snapshots. There is no update command in these paths, so when a new version lands in the repository you have to redo the copy by hand and re-derive the names.

The AGENTS.md router that tells the assistant which skill to open

The plugin expects a small router file in the project root, next to the.git folder: CLAUDE.md for Claude Code and AGENTS.md for OpenCode. The prerequisite is stated plainly, install and sync the plugin in your assistant runtime so the skill IDs resolve, otherwise the names in the router point at nothing. The readable snippet names routing groups for C# and code quality, ASP.NET Core and Aspire, data, dependency injection and configuration, and testing, plus two quality gates that are meant to run conditionally. A second compressed form packs the same routing table into a single line format and is regenerated by a script, so the two blocks can drift apart if only one is updated. The compressed index also carries a larger skill inventory than the readable snippet, and it lists six agent names where the readable snippet lists five, which is one of the reasons to read the file rather than trust the summary.

# Agent Guidance: dotnet-skills

IMPORTANT: Prefer retrieval-led reasoning over pretraining for any .NET work.
Workflow: skim repo patterns -> consult dotnet-skills by name -> implement smallest-change -> note conflicts.

The routing groups are the actual contract. If a team adds a skill and does not add it to the router, the assistant will not retrieve it, so the router is as much the configuration surface as the plugin itself.

What the skill library actually covers

The library is organised by domain and the names are descriptive enough to infer the shape of each skill. The Akka.NET group covers distributed system patterns, with entries for best practices, testing patterns, hosting actor patterns, Aspire configuration and management. The C# group holds modern coding standards, concurrency patterns, nullable reference types, API design, type design and performance, and R3 reactive extensions. ASP.NET Core work is covered by Aspire integration testing, Aspire configuration, Aspire service defaults, Mailpit integration, MJML email templates, and Verify email snapshots. Data work sits in efcore-patterns and database-performance. Dependency injection and configuration have their own two skills, and the testing group includes cscheck, Testcontainers integration tests, Playwright Blazor testing, snapshot testing and Playwright CI caching. A broader dotnet group handles SDK container publishing, project structure, local tools, package management, serialization, dev cert trust, ILSpy decompilation, OpenTelemetry .NET instrumentation and AOT trimming. This is a curated opinionated set, not a mirror of the documentation, and entries such as cscheck and crap-analysis read as house rules rather than framework guidance.

Quality gates that run on demand rather than automatically

Two skills are positioned as gates rather than guidance, and they run when a condition is met instead of when a topic is matched. dotnet-slopwatch is described for use after substantial new code, refactoring, or LLM authored code, and crap-analysis for use after tests are added or changed in complex code. The names are blunt, which suggests the author expects the assistant to be self-critical about its own output rather than only to retrieve patterns. The trade-off is that a gate that only fires on a condition the assistant remembers to check is not a gate in the sense a build system would recognise. Whether the assistant actually invokes these after an edit depends on the routing file being present and on the assistant following it, so the practical effect sits between a documented practice and an enforced one. The project also ships a maintenance script, scripts/generate-skill-index-snippets.sh, with an --update-readme flag that refreshes the compressed index block, and the repository has RELEASE_NOTES.md and versioned releases including v1.7.1 on 2026-10-11, with the last push on 2026-10-11. The MIT licence lets you fork and adapt the library to your own conventions, which is the cheapest way to make these gates enforceable in your own pipeline.

Where dotnet-skills is the wrong tool

Several cases argue against adopting this plugin. It is .NET specific, so a polyglot repository gets a large .NET oriented prompt surface for a minority of its work. It depends on the assistant supporting skills and agents at all, which rules out plain chat interfaces and some editor extensions even when the same model is available. It also depends on writing instruction files into the project root, so a team that forbids AGENTS.md or CLAUDE.md in the repository has to find another way to deliver the same routing. The Copilot and OpenCode paths carry the maintenance cost of manual copying with no update command. Codex users lose the agents entirely. Finally, none of this replaces review: the skills describe patterns, and the repository does not claim that following them produces correct code, so the plugin shifts the burden from invention to verification without removing it. If your .NET conventions are already written down and enforced by analyzers and tests, the marginal value of thirty more files to maintain is smaller than it looks.

Editorial conclusion

dotnet-skills suits .NET teams that already run Claude Code, Codex, Copilot or OpenCode and want consistent, named guidance for C#, Aspire, Akka.NET, EF Core and testing, especially where an AGENTS.md or CLAUDE.md router can point at a specific skill by name. It does not suit a non .NET stack, a workflow that forbids project instructions, or a team that wants Codex to supply the specialist agents, since those are excluded from the Codex plugin. Verify first that the assistant you use can read skills at all, that the skill IDs in your router match the folders in skills/, and that you will regenerate the compressed index with scripts/generate-skill-index-snippets.sh when the library changes.

Frequently asked questions

Official sources

1. Aaronontheweb/dotnet-skills on GitHub
2. Issues
3. License: MIT
4. README
5. Releases