Skip to content
Back to search

dotnet-artisan

MarketplaceWorks with Claude CodeGitHub

Marketplace metadata for the dotnet-artisan Claude Code plugin

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/novotnyllc--dotnet-artisan/badge.svg)](/listings/novotnyllc--dotnet-artisan)

HTML

<a href="/listings/novotnyllc--dotnet-artisan"><img src="/api/listings/novotnyllc--dotnet-artisan/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Claude Code

From within Claude Code, run:

/plugin marketplace add novotnyllc/dotnet-artisan
/plugin install dotnet-artisan@dotnet-artisan

Once installed, Claude Code automatically loads relevant skills based on your questions about .NET development.

OpenCode (oh-my-opencode)

OpenCode supports Claude Code plugins. Install with Claude Code first using:

/plugin marketplace add novotnyllc/dotnet-artisan
/plugin install dotnet-artisan@dotnet-artisan

Then set this in `~/.config/opencode/oh-my-opencode.json`:

{
  "claude_code": {
    "plugins": true
  }
}

GitHub Copilot CLI

Install as a Copilot plugin:

copilot plugin marketplace add novotnyllc/dotnet-artisan
copilot plugin install dotnet-artisan@dotnet-artisan

The plugin keeps a flat `plugins/dotnet-artisan/skills/<skill-name>/` layout, which remains compatible with Copilot's one-level-deep skill scanning.

OpenAI Codex

Codex installs from the shared Claire Novotny LLC plugin marketplace:

codex plugin marketplace add novotnyllc/marketplace
codex plugin add dotnet-artisan --marketplace novotnyllc

The 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-artisan

You 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.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 40 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "dotnet-artisan",
  4. "description": "Marketplace metadata for the dotnet-artisan Claude Code plugin",
  5. "owner": {
  6. "name": "Claire Novotny",
  7. "url": "https://github.com/novotnyllc"
  8. },
  9. "metadata": {
  10. "description": "Marketplace metadata for the dotnet-artisan plugin",
  11. "version": "1.5.0"
  12. },
  13. "plugins": [
  14. {
  15. "name": "dotnet-artisan",
  16. "source": "./plugins/dotnet-artisan",
  17. "description": "Comprehensive .NET development skills for modern C# and .NET",
  18. "version": "1.5.0",
  19. "author": {
  20. "name": "Claire Novotny",
  21. "url": "https://github.com/novotnyllc"
  22. },
  23. "license": "MIT",
  24. "category": "development",
  25. "homepage": "https://github.com/novotnyllc/dotnet-artisan/tree/main",
  26. "keywords": [
  27. "dotnet",
  28. "csharp",
  29. "aspnet",
  30. "blazor",
  31. "maui",
  32. "uno-platform",
  33. "efcore",
  34. "native-aot",
  35. "cloud-native",
  36. "testing"
  37. ]
  38. }
  39. ]
  40. }
README.md · README · 276 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # dotnet-artisan
  2. > Comprehensive .NET development skills for modern C#, ASP.NET, MAUI, Blazor, and cloud-native applications
  3. [![CI](https://github.com/novotnyllc/dotnet-artisan/actions/workflows/validate.yml/badge.svg)](https://github.com/novotnyllc/dotnet-artisan/actions/workflows/validate.yml)
  4. [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
  5. [![Version](https://img.shields.io/badge/version-1.5.0-green.svg)](plugins/dotnet-artisan/.claude-plugin/plugin.json)
  6. ## Overview
  7. **dotnet-artisan** provides 10 skills (2 routing + 8 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.
  8. The plugin covers the full breadth of the .NET ecosystem:
  9. - Modern C# patterns, async/await, dependency injection, and source generators
  10. - ASP.NET Core APIs, Blazor, MAUI, Uno Platform, WinUI, and WPF
  11. - Entity Framework Core, data access strategies, and serialization
  12. - Testing with xUnit, integration testing, Playwright, and snapshot testing
  13. - CI/CD for GitHub Actions and Azure DevOps
  14. - Native AOT, trimming, performance profiling, and benchmarking
  15. - Security, packaging, documentation, and release management
  16. ## Installation
  17. ### Claude Code
  18. From within Claude Code, run:
  19. ```bash
  20. /plugin marketplace add novotnyllc/dotnet-artisan
  21. /plugin install dotnet-artisan@dotnet-artisan
  22. ```
  23. Once installed, Claude Code automatically loads relevant skills based on your questions about .NET development.
  24. ### OpenCode (oh-my-opencode)
  25. OpenCode supports Claude Code plugins. Install with Claude Code first using:
  26. ```bash
  27. /plugin marketplace add novotnyllc/dotnet-artisan
  28. /plugin install dotnet-artisan@dotnet-artisan
  29. ```
  30. Then set this in `~/.config/opencode/oh-my-opencode.json`:
  31. ```json
  32. {
  33. "claude_code": {
  34. "plugins": true
  35. }
  36. }
  37. ```
  38. ### GitHub Copilot CLI
  39. Install as a Copilot plugin:
  40. ```bash
  41. copilot plugin marketplace add novotnyllc/dotnet-artisan
  42. copilot plugin install dotnet-artisan@dotnet-artisan
  43. ```
  44. The plugin keeps a flat `plugins/dotnet-artisan/skills/<skill-name>/` layout, which remains compatible with Copilot's one-level-deep skill scanning.
  45. ### OpenAI Codex
  46. Codex installs from the shared Claire Novotny LLC plugin marketplace:
  47. ```bash
  48. codex plugin marketplace add novotnyllc/marketplace
  49. codex plugin add dotnet-artisan --marketplace novotnyllc
  50. ```
  51. The 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.
  52. For direct skill-centric installs, use:
  53. ```bash
  54. $skill-installer install https://github.com/novotnyllc/dotnet-artisan/tree/main/plugins/dotnet-artisan
  55. ```
  56. You can also sync skill directories into `~/.codex/skills/`.
  57. Root `agents/*.md` specialist definitions are not yet first-class Codex skills, so Codex still routes through the broad skill layer.
  58. ## Provider Support Matrix
  59. | Provider | Primary surface | Status |
  60. |---|---|---|
  61. | Claude Code | `.claude-plugin/marketplace.json` -> `plugins/dotnet-artisan/.claude-plugin/plugin.json` + skills + agents + hooks + MCP | Supported |
  62. | GitHub Copilot CLI | root marketplace -> `plugins/dotnet-artisan/.claude-plugin/plugin.json` + skills + agents | Supported |
  63. | OpenAI Codex | `novotnyllc/marketplace` -> `plugins/dotnet-artisan/.codex-plugin/plugin.json` + skills | Supported |
  64. Compatibility is validated in CI with structural smoke checks via `scripts/run-agent-routing-smoke.py --provider claude,codex,copilot`.
  65. ## Skill Catalog
  66. The plugin organizes 10 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](https://github.com/anthropics/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.
  67. | Skill | Domain | Key Topics |
  68. |---|---|---|
  69. | **using-dotnet** | Gateway routing | Detects .NET intent, enforces skill invocation before planning |
  70. | **dotnet-advisor** | Router/dispatcher | Routes queries to domain skills, loads coding standards as baseline |
  71. | **dotnet-csharp** | C# language & runtime | Modern patterns, async/await, DI, config, source generators, LINQ, concurrency, SOLID |
  72. | **dotnet-api** | ASP.NET Core & backend | Minimal APIs, EF Core, gRPC, SignalR, security (OWASP), messaging, Aspire, Semantic Kernel, architecture patterns |
  73. | **dotnet-ui** | UI frameworks | Blazor, MAUI, Uno Platform, WPF, WinUI, WinForms, accessibility, localization |
  74. | **dotnet-testing** | Testing & quality | xUnit, integration/E2E, Playwright, BenchmarkDotNet, snapshot testing, test strategy |
  75. | **dotnet-devops** | CI/CD & operations | GitHub Actions, Azure DevOps, containers, NuGet, MSIX, observability, structured logging |
  76. | **dotnet-tooling** | Build & developer tools | MSBuild, Native AOT, trimming, CLI apps, profiling, version detection, project setup |
  77. | **dotnet-debugging** | Debugging | WinDbg debugging, memory analysis, dump file investigation |
  78. | **dotnet-library-docs** | Library docs | Current NuGet/third-party library docs via the Context7 HTTP API (curl, on demand) |
  79. ## Agents
  80. The plugin includes 14 specialist agents that provide focused expertise in specific domains.
  81. Provider note:
  82. - Claude/Copilot flows can use these specialist agent definitions directly.
  83. - Codex currently routes through broad skills; use the `dotnet-advisor` Codex fallback table to map specialist intents to skills/references.
  84. | Agent | Description |
  85. |---|---|
  86. | **dotnet-architect** | Analyzes project context, requirements, and constraints to recommend architecture approaches, framework choices, and design patterns |
  87. | **dotnet-csharp-concurrency-specialist** | Debugs race conditions, deadlocks, thread safety issues, and synchronization problems in .NET code |
  88. | **dotnet-security-reviewer** | Reviews .NET code for security vulnerabilities, OWASP compliance, secrets exposure, and cryptographic misuse |
  89. | **dotnet-blazor-specialist** | Guides Blazor development across all hosting models (Server, WASM, Hybrid, Auto) including components, state, and auth |
  90. | **dotnet-uno-specialist** | Builds cross-platform Uno Platform apps with Extensions ecosystem, MVUX patterns, Toolkit controls, and MCP integration |
  91. | **dotnet-maui-specialist** | Builds .NET MAUI apps with platform-specific development, Xamarin migration, and Native AOT on iOS/Catalyst |
  92. | **dotnet-performance-analyst** | Analyzes profiling data, benchmark results, GC behavior, and diagnoses performance bottlenecks |
  93. | **dotnet-benchmark-designer** | Designs BenchmarkDotNet benchmarks, prevents measurement bias, and validates benchmark methodology |
  94. | **dotnet-docs-generator** | Generates documentation including Mermaid diagrams, XML doc skeletons, and GitHub-native docs |
  95. | **dotnet-async-performance-specialist** | Analyzes ValueTask correctness, ConfigureAwait decisions, async overhead, ThreadPool tuning |
  96. | **dotnet-aspnetcore-specialist** | Guides middleware authoring, DI patterns, minimal API design, and request pipeline optimization |
  97. | **dotnet-testing-specialist** | Designs test pyramids, unit vs integration vs E2E boundaries, test data management |
  98. | **dotnet-cloud-specialist** | Guides .NET Aspire orchestration, AKS deployment, distributed tracing, infrastructure-as-code |
  99. | **dotnet-code-review-agent** | Performs multi-dimensional code review across correctness, performance, security, and architecture |
  100. ## Architecture
  101. ### Plugin Structure
  102. ```mermaid
  103. graph TB
  104. subgraph Plugin["dotnet-artisan Plugin"]
  105. direction TB
  106. MP[Marketplace indexes]
  107. PJ[plugins/dotnet-artisan<br/>plugin manifests]
  108. subgraph Agents["14 Specialist Agents"]
  109. DA[dotnet-architect<br/>Central Router]
  110. CSC[concurrency-specialist]
  111. SR[security-reviewer]
  112. BSA[blazor-specialist]
  113. US[uno-specialist]
  114. MS[maui-specialist]
  115. PA[performance-analyst]
  116. BD[benchmark-designer]
  117. DG[docs-generator]
  118. ASP[async-performance-specialist]
  119. ASN[aspnetcore-specialist]
  120. TS[testing-specialist]
  121. CLS[cloud-specialist]
  122. CR[code-review-agent]
  123. end
  124. subgraph Skills["10 Skills"]
  125. UD[using-dotnet<br/>Gateway]
  126. ADV[dotnet-advisor<br/>Router]
  127. CS[dotnet-csharp<br/>C# Language]
  128. API[dotnet-api<br/>ASP.NET/Backend]
  129. UIS[dotnet-ui<br/>UI Frameworks]
  130. TEST[dotnet-testing<br/>Testing/Quality]
  131. DEVOPS[dotnet-devops<br/>CI/CD/Ops]
  132. TOOL[dotnet-tooling<br/>Build/Tools]
  133. DBG[dotnet-debugging<br/>Debugging]
  134. DOCS[dotnet-library-docs<br/>Library Docs]
  135. end
  136. subgraph Infra["Infrastructure"]
  137. HK[hooks.json]
  138. MCP[.mcp.json]
  139. end
  140. end
  141. MP --> PJ
  142. DA --> BSA
  143. DA --> US
  144. DA --> MS
  145. DA --> CSC
  146. DA --> SR
  147. DA --> PA
  148. DA --> BD
  149. DA --> DG
  150. DA --> ASP
  151. DA --> ASN
  152. DA --> TS
  153. DA --> CS
  154. DA --> CR
  155. BSA --> UIS
  156. US --> UIS
  157. MS --> UIS
  158. CSC --> CS
  159. SR --> API
  160. PA --> TOOL
  161. BD --> TEST
  162. DG --> TOOL
  163. DA --> API
  164. DA --> CS
  165. UD --> ADV
  166. ADV --> CS
  167. ADV --> API
  168. ADV --> UIS
  169. ADV --> TEST
  170. ADV --> DEVOPS
  171. ADV --> TOOL
  172. ADV --> DBG
  173. ```
  174. ### Skill Routing Flow
  175. ```mermaid
  176. sequenceDiagram
  177. participant User
  178. participant Claude as Claude Code
  179. participant Gateway as using-dotnet<br/>(Gateway Skill)
  180. participant Advisor as dotnet-advisor<br/>(Router Skill)
  181. participant Domain as Domain Skill
  182. participant Ref as references/*.md
  183. User->>Claude: "How do I set up Blazor auth?"
  184. Claude->>Gateway: Detect .NET intent
  185. Gateway->>Advisor: Route to advisor
  186. Advisor->>Advisor: Match query to domain skill
  187. Advisor->>Domain: Load dotnet-ui
  188. Domain->>Ref: Load blazor-auth.md
  189. Ref-->>Claude: Structured guidance
  190. Claude-->>User: Blazor auth setup<br/>with code examples
  191. ```
  192. ## Usage Examples
  193. **Ask about project architecture:**
  194. > "I have a new .NET 9 web API project. What architecture pattern should I use for a medium-sized e-commerce backend?"
  195. 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.
  196. **Debug a concurrency issue:**
  197. > "I'm getting intermittent failures in my background service that processes messages from a queue. Sometimes messages are processed twice."
  198. 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.
  199. **Set up CI/CD:**
  200. > "Help me create a GitHub Actions workflow that builds, tests, and publishes my NuGet package."
  201. Claude Code loads `dotnet-devops` (read `references/gha-patterns.md`) to generate a complete workflow with proper versioning, test matrix, and NuGet push configuration.
  202. ## Agent Skill Routing Checks
  203. 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.
  204. See `docs/agent-routing-tests.md` for details, workflow inputs, and environment variables.
  205. ## Contributing
  206. See [CONTRIBUTING-SKILLS.md](CONTRIBUTING-SKILLS.md) for the skill authoring guide, or [CONTRIBUTING.md](CONTRIBUTING.md) for the general contribution workflow.
  207. ## Acknowledgements
  208. - The [Claude Code plugin system](https://docs.anthropic.com/en/docs/claude-code/plugins) and [Agent Skills](https://github.com/anthropics/agent-skills) open standard for enabling structured, discoverable development skills
  209. - The [.NET community and ecosystem](https://dotnet.microsoft.com/) for the frameworks, libraries, and patterns documented in these skills
  210. - All [contributors](https://github.com/novotnyllc/dotnet-artisan/graphs/contributors) who help improve and expand the plugin
  211. ## License
  212. This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.