Comprehensive .NET development skills for modern C#, ASP.NET, MAUI, Blazor, and cloud-native applications
dotnet-artisan provides 9 skills (2 routing + 7 domain) and 14 specialist agents for .NET development. It is compatible with Claude Code, GitHub Copilot CLI, and OpenAI Codex. The installable plugin lives at plugins/dotnet-artisan. Claude and Copilot consume the Claude plugin manifest there through the root marketplace, while Codex discovers the same plugin through the shared Claire Novotny LLC marketplace and plugins/dotnet-artisan/.codex-plugin/plugin.json. Specialist agents/*.md are currently used by Claude/Copilot flows; Codex routes through the skills/* surface.
The plugin covers the full breadth of the .NET ecosystem:
- Modern C# patterns, async/await, dependency injection, and source generators
- ASP.NET Core APIs, Blazor, MAUI, Uno Platform, WinUI, and WPF
- Entity Framework Core, data access strategies, and serialization
- Testing with xUnit, integration testing, Playwright, and snapshot testing
- CI/CD for GitHub Actions and Azure DevOps
- Native AOT, trimming, performance profiling, and benchmarking
- Security, packaging, documentation, and release management
From within Claude Code, run:
/plugin marketplace add novotnyllc/dotnet-artisan
/plugin install dotnet-artisan@dotnet-artisanOnce installed, Claude Code automatically loads relevant skills based on your questions about .NET development.
OpenCode supports Claude Code plugins. Install with Claude Code first using:
/plugin marketplace add novotnyllc/dotnet-artisan
/plugin install dotnet-artisan@dotnet-artisanThen set this in ~/.config/opencode/oh-my-opencode.json:
{
"claude_code": {
"plugins": true
}
}Install as a Copilot plugin:
copilot plugin marketplace add novotnyllc/dotnet-artisan
copilot plugin install dotnet-artisan@dotnet-artisanThe plugin keeps a flat plugins/dotnet-artisan/skills/<skill-name>/ layout, which remains compatible with Copilot's one-level-deep skill scanning.
Codex installs from the shared Claire Novotny LLC plugin marketplace:
codex plugin marketplace add novotnyllc/marketplace
codex plugin add dotnet-artisan --marketplace novotnyllcThe shared marketplace entry resolves to plugins/dotnet-artisan, where the plugin's skills/, agents/, hooks.json, .mcp.json, .claude-plugin/, and .codex-plugin/ files live.
For direct skill-centric installs, use:
$skill-installer install https://github.com/novotnyllc/dotnet-artisan/tree/main/plugins/dotnet-artisanYou can also sync skill directories into ~/.codex/skills/.
Root agents/*.md specialist definitions are not yet first-class Codex skills, so Codex still routes through the broad skill layer.
| Provider | Primary surface | Status |
|---|---|---|
| Claude Code | .claude-plugin/marketplace.json -> plugins/dotnet-artisan/.claude-plugin/plugin.json + skills + agents + hooks + MCP |
Supported |
| GitHub Copilot CLI | root marketplace -> plugins/dotnet-artisan/.claude-plugin/plugin.json + skills + agents |
Supported |
| OpenAI Codex | novotnyllc/marketplace -> plugins/dotnet-artisan/.codex-plugin/plugin.json + skills |
Supported |
Compatibility is validated in CI with structural smoke checks via scripts/run-agent-routing-smoke.py --provider claude,codex,copilot.
The plugin organizes 9 skills in a flat directory layout (plugins/dotnet-artisan/skills/<skill-name>/SKILL.md), backed by 159 reference files (~62K lines) of deep-dive guidance loaded on demand. Each skill follows the Agent Skills open standard with structured frontmatter and progressive disclosure — SKILL.md routing tables point to references/*.md companion files that Claude reads only when relevant.
| Skill | Domain | Key Topics |
|---|---|---|
| using-dotnet | Gateway routing | Detects .NET intent, enforces skill invocation before planning |
| dotnet-advisor | Router/dispatcher | Routes queries to domain skills, loads coding standards as baseline |
| dotnet-csharp | C# language & runtime | Modern patterns, async/await, DI, config, source generators, LINQ, concurrency, SOLID |
| dotnet-api | ASP.NET Core & backend | Minimal APIs, EF Core, gRPC, SignalR, security (OWASP), messaging, Aspire, Semantic Kernel, architecture patterns |
| dotnet-ui | UI frameworks | Blazor, MAUI, Uno Platform, WPF, WinUI, WinForms, accessibility, localization |
| dotnet-testing | Testing & quality | xUnit, integration/E2E, Playwright, BenchmarkDotNet, snapshot testing, test strategy |
| dotnet-devops | CI/CD & operations | GitHub Actions, Azure DevOps, containers, NuGet, MSIX, observability, structured logging |
| dotnet-tooling | Build & developer tools | MSBuild, Native AOT, trimming, CLI apps, profiling, version detection, project setup |
| dotnet-debugging | Debugging | WinDbg debugging, memory analysis, dump file investigation |
The plugin includes 14 specialist agents that provide focused expertise in specific domains.
Provider note:
- Claude/Copilot flows can use these specialist agent definitions directly.
- Codex currently routes through broad skills; use the
dotnet-advisorCodex fallback table to map specialist intents to skills/references.
| Agent | Description |
|---|---|
| dotnet-architect | Analyzes project context, requirements, and constraints to recommend architecture approaches, framework choices, and design patterns |
| dotnet-csharp-concurrency-specialist | Debugs race conditions, deadlocks, thread safety issues, and synchronization problems in .NET code |
| dotnet-security-reviewer | Reviews .NET code for security vulnerabilities, OWASP compliance, secrets exposure, and cryptographic misuse |
| dotnet-blazor-specialist | Guides Blazor development across all hosting models (Server, WASM, Hybrid, Auto) including components, state, and auth |
| dotnet-uno-specialist | Builds cross-platform Uno Platform apps with Extensions ecosystem, MVUX patterns, Toolkit controls, and MCP integration |
| dotnet-maui-specialist | Builds .NET MAUI apps with platform-specific development, Xamarin migration, and Native AOT on iOS/Catalyst |
| dotnet-performance-analyst | Analyzes profiling data, benchmark results, GC behavior, and diagnoses performance bottlenecks |
| dotnet-benchmark-designer | Designs BenchmarkDotNet benchmarks, prevents measurement bias, and validates benchmark methodology |
| dotnet-docs-generator | Generates documentation including Mermaid diagrams, XML doc skeletons, and GitHub-native docs |
| dotnet-async-performance-specialist | Analyzes ValueTask correctness, ConfigureAwait decisions, async overhead, ThreadPool tuning |
| dotnet-aspnetcore-specialist | Guides middleware authoring, DI patterns, minimal API design, and request pipeline optimization |
| dotnet-testing-specialist | Designs test pyramids, unit vs integration vs E2E boundaries, test data management |
| dotnet-cloud-specialist | Guides .NET Aspire orchestration, AKS deployment, distributed tracing, infrastructure-as-code |
| dotnet-code-review-agent | Performs multi-dimensional code review across correctness, performance, security, and architecture |
graph TB
subgraph Plugin["dotnet-artisan Plugin"]
direction TB
MP[Marketplace indexes]
PJ[plugins/dotnet-artisan<br/>plugin manifests]
subgraph Agents["14 Specialist Agents"]
DA[dotnet-architect<br/>Central Router]
CSC[concurrency-specialist]
SR[security-reviewer]
BSA[blazor-specialist]
US[uno-specialist]
MS[maui-specialist]
PA[performance-analyst]
BD[benchmark-designer]
DG[docs-generator]
ASP[async-performance-specialist]
ASN[aspnetcore-specialist]
TS[testing-specialist]
CLS[cloud-specialist]
CR[code-review-agent]
end
subgraph Skills["9 Skills"]
UD[using-dotnet<br/>Gateway]
ADV[dotnet-advisor<br/>Router]
CS[dotnet-csharp<br/>C# Language]
API[dotnet-api<br/>ASP.NET/Backend]
UIS[dotnet-ui<br/>UI Frameworks]
TEST[dotnet-testing<br/>Testing/Quality]
DEVOPS[dotnet-devops<br/>CI/CD/Ops]
TOOL[dotnet-tooling<br/>Build/Tools]
DBG[dotnet-debugging<br/>Debugging]
end
subgraph Infra["Infrastructure"]
HK[hooks.json]
MCP[.mcp.json]
end
end
MP --> PJ
DA --> BSA
DA --> US
DA --> MS
DA --> CSC
DA --> SR
DA --> PA
DA --> BD
DA --> DG
DA --> ASP
DA --> ASN
DA --> TS
DA --> CS
DA --> CR
BSA --> UIS
US --> UIS
MS --> UIS
CSC --> CS
SR --> API
PA --> TOOL
BD --> TEST
DG --> TOOL
DA --> API
DA --> CS
UD --> ADV
ADV --> CS
ADV --> API
ADV --> UIS
ADV --> TEST
ADV --> DEVOPS
ADV --> TOOL
ADV --> DBG
sequenceDiagram
participant User
participant Claude as Claude Code
participant Gateway as using-dotnet<br/>(Gateway Skill)
participant Advisor as dotnet-advisor<br/>(Router Skill)
participant Domain as Domain Skill
participant Ref as references/*.md
User->>Claude: "How do I set up Blazor auth?"
Claude->>Gateway: Detect .NET intent
Gateway->>Advisor: Route to advisor
Advisor->>Advisor: Match query to domain skill
Advisor->>Domain: Load dotnet-ui
Domain->>Ref: Load blazor-auth.md
Ref-->>Claude: Structured guidance
Claude-->>User: Blazor auth setup<br/>with code examples
Ask about project architecture:
"I have a new .NET 9 web API project. What architecture pattern should I use for a medium-sized e-commerce backend?"
Claude Code loads dotnet-api (read references/architecture-patterns.md) and dotnet-tooling (read references/project-structure.md) to recommend a clean architecture approach with specific project layout, middleware pipeline, and dependency injection configuration.
Debug a concurrency issue:
"I'm getting intermittent failures in my background service that processes messages from a queue. Sometimes messages are processed twice."
The dotnet-csharp-concurrency-specialist agent activates, loading dotnet-csharp (read references/async-patterns.md and references/concurrency-patterns.md) to diagnose the race condition and recommend idempotency patterns.
Set up CI/CD:
"Help me create a GitHub Actions workflow that builds, tests, and publishes my NuGet package."
Claude Code loads dotnet-devops (read references/gha-patterns.md) to generate a complete workflow with proper versioning, test matrix, and NuGet push configuration.
This repo includes a CI-ready routing checker to verify that agents discover and use expected skills. Structural validators (validate-skills.sh, validate-marketplace.sh) run on every push and PR. CI also installs the current Codex and Claude CLIs, verifies the Codex plugin manifest, and installs the Claude plugin from the same checkout. Live routing checks run via ./test.sh as optional manual verification.
See docs/agent-routing-tests.md for details, workflow inputs, and environment variables.
See CONTRIBUTING-SKILLS.md for the skill authoring guide, or CONTRIBUTING.md for the general contribution workflow.
- The Claude Code plugin system and Agent Skills open standard for enabling structured, discoverable development skills
- The .NET community and ecosystem for the frameworks, libraries, and patterns documented in these skills
- All contributors who help improve and expand the plugin
This project is licensed under the MIT License. See the LICENSE file for details.