Skip to content
Back to search

dotnet-skills

SkillWorks with Claude CodeGitHub

Claude Code skills and sub-agents for .NET Developers

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/wshaddix--dotnet-skills/badge.svg)](/listings/wshaddix--dotnet-skills)

HTML

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

Install

i

Install instructions from the README

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

This plugin works with multiple AI coding assistants that support skills/agents.

Claude Code (CLI)

[Official Docs](https://code.claude.com/docs/en/discover-plugins)

Run these commands inside the Claude Code CLI (the terminal app, not the VSCode extension):

/plugin marketplace add Aaronontheweb/dotnet-skills
/plugin install dotnet-skills

To update:

/plugin marketplace update

GitHub Copilot

[Official Docs](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills)

Clone or copy skills to your project or global config:

**Project-level** (recommended):

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

**Global** (all projects):

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

OpenCode

[Official Docs](https://opencode.ai/docs/skills)

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

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/

---

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.

README.md · README · 399 lines

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

  1. # .NET Skills for Claude Code
  2. A comprehensive Claude Code plugin with **167 skills** and **16 specialized agents** for professional .NET development. Combines battle-tested patterns from production systems with comprehensive coverage of the entire .NET ecosystem including C#, ASP.NET Core, Blazor, MAUI, EF Core, Native AOT, testing, security, performance optimization, CI/CD, and cloud-native applications.
  3. ## Installation
  4. This plugin works with multiple AI coding assistants that support skills/agents.
  5. ### Claude Code (CLI)
  6. [Official Docs](https://code.claude.com/docs/en/discover-plugins)
  7. Run these commands inside the Claude Code CLI (the terminal app, not the VSCode extension):
  8. ```
  9. /plugin marketplace add Aaronontheweb/dotnet-skills
  10. /plugin install dotnet-skills
  11. ```
  12. To update:
  13. ```
  14. /plugin marketplace update
  15. ```
  16. ### GitHub Copilot
  17. [Official Docs](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills)
  18. Clone or copy skills to your project or global config:
  19. **Project-level** (recommended):
  20. ```bash
  21. git clone https://github.com/Aaronontheweb/dotnet-skills.git /tmp/dotnet-skills
  22. cp -r /tmp/dotnet-skills/skills/* .github/skills/
  23. ```
  24. **Global** (all projects):
  25. ```bash
  26. mkdir -p ~/.copilot/skills
  27. cp -r /tmp/dotnet-skills/skills/* ~/.copilot/skills/
  28. ```
  29. ### OpenCode
  30. [Official Docs](https://opencode.ai/docs/skills)
  31. ```bash
  32. git clone https://github.com/Aaronontheweb/dotnet-skills.git /tmp/dotnet-skills
  33. mkdir -p ~/.config/opencode/skills ~/.config/opencode/agents
  34. for skill_file in /tmp/dotnet-skills/skills/*/SKILL.md; do
  35. skill_name=$(grep -m1 "^name:" "$skill_file" | sed 's/name: *//')
  36. mkdir -p ~/.config/opencode/skills/$skill_name
  37. cp "$skill_file" ~/.config/opencode/skills/$skill_name/SKILL.md
  38. done
  39. cp /tmp/dotnet-skills/agents/*.md ~/.config/opencode/agents/
  40. ```
  41. ---
  42. ## Add to AGENTS.md
  43. Copy the following snippet into your project's `AGENTS.md` file to enable intelligent skill routing:
  44. ```markdown
  45. ## .NET Skill Library
  46. You have access to a comprehensive .NET skill library. Use these skills for any C#/.NET development work. Always prefer skill-guided patterns over pre-training knowledge.
  47. ### Skill Routing by Task Type
  48. **Writing C# Code:**
  49. - `modern-csharp-coding-standards` - Records, pattern matching, immutability, value objects, async patterns
  50. - `csharp-concurrency-patterns` - Choosing between async/await, Channels, locks, synchronization primitives
  51. - `csharp-api-design` - API surface design, versioning, backward compatibility
  52. - `csharp-type-design-performance` - Sealed classes, readonly structs, Span<T>, Memory<T>
  53. **Entity Framework Core:**
  54. - `efcore-patterns` - DbContext lifecycle, NoTracking, query splitting, migrations, interceptors
  55. - `database-performance` - N+1 prevention, read/write separation, query optimization
  56. **ASP.NET Core Web:**
  57. - `middleware-patterns` - Pipeline ordering, custom middleware, exception handling
  58. - `razor-pages-patterns` - Page models, validation, anti-forgery, routing
  59. - `validation-patterns` - FluentValidation, DataAnnotations, custom validators
  60. - `exception-handling` - ProblemDetails, global handlers, error responses
  61. - `caching-strategies` - Output caching, Redis, HybridCache (.NET 9+)
  62. - `rate-limiting` - Request throttling, sliding window, concurrency limits
  63. - `security-headers` - CSP, HSTS, CORS, security middleware
  64. **Background Processing:**
  65. - `background-services` - BackgroundService, IHostedService, outbox pattern, graceful shutdown
  66. - `dotnet-channels` - Producer/consumer, bounded channels, backpressure
  67. **Dependency Injection:**
  68. - `microsoft-extensions-dependency-injection` - Service lifetimes, keyed services, factory patterns
  69. - `microsoft-extensions-configuration` - IOptions, configuration providers, secrets
  70. **Testing:**
  71. - `dotnet-testing-strategy` - Test pyramid, unit vs integration decisions
  72. - `dotnet-xunit` - xUnit patterns, fixtures, theory data
  73. - `testcontainers` - Docker-based integration tests, database fixtures
  74. - `snapshot-testing` - Verify library, approval testing
  75. - `dotnet-playwright` - E2E browser testing
  76. - `crap-analysis` - CRAP scores, coverage analysis
  77. **Performance:**
  78. - `dotnet-benchmarkdotnet` - Benchmark design, measurement methodology
  79. - `dotnet-performance-patterns` - Allocation reduction, GC optimization
  80. - `dotnet-profiling` - Profiler usage, hotspot identification
  81. - `dotnet-gc-memory` - GC modes, memory pressure, Large Object Heap
  82. **Native AOT:**
  83. - `dotnet-native-aot` - AOT compilation, publishing, constraints
  84. - `dotnet-trimming` - Size optimization, linker configuration
  85. - `dotnet-aot-wasm` - WASM AOT with Blazor
  86. **Security:**
  87. - `dotnet-security-owasp` - OWASP Top 10 for .NET
  88. - `dotnet-cryptography` - Encryption, hashing, key management
  89. - `dotnet-secrets-management` - Secret storage, Azure Key Vault, user secrets
  90. - `asp-net-core-identity-patterns` - Authentication, authorization, MFA
  91. **UI Frameworks:**
  92. - `dotnet-blazor-patterns` - Server/WASM/Hybrid patterns
  93. - `dotnet-blazor-components` - Component lifecycle, rendering
  94. - `dotnet-maui-development` - Cross-platform mobile/desktop
  95. - `dotnet-winui` - Windows App SDK, WinUI 3
  96. - `razor-pages-patterns` - Server-side web UI
  97. **CI/CD:**
  98. - `dotnet-gha-patterns` - GitHub Actions workflow patterns
  99. - `dotnet-gha-build-test` - Build/test matrix, caching
  100. - `dotnet-gha-publish` - NuGet, container publishing
  101. - `dotnet-ado-patterns` - Azure DevOps pipelines
  102. **Architecture:**
  103. - `dotnet-architecture-patterns` - Clean architecture, vertical slice, modular monolith
  104. - `dotnet-solid-principles` - SOLID in practice
  105. - `dotnet-domain-modeling` - DDD patterns, aggregates
  106. - `project-structure` - Solution layout, Directory.Build.props
  107. **Deployment:**
  108. - `fly-io` - Fly.io deployment, Machines, Volumes, networking
  109. - `dotnet-containers` - Docker for .NET
  110. - `dotnet-container-deployment` - Container orchestration
  111. **Specialized Frameworks:**
  112. - `csharp-wolverinefx` - Messaging, HTTP services, Marten event sourcing
  113. - `aspire-configuration` - .NET Aspire AppHost configuration
  114. - `aspire-integration-testing` - Aspire testing patterns
  115. - `signalr-integration` - Real-time communication
  116. ### Meta-Skills (Run After Changes)
  117. - `slopwatch` - Detect LLM-generated anti-patterns
  118. - `dotnet-agent-gotchas` - Common AI mistakes in .NET
  119. - `dotnet-build-analysis` - Build output analysis
  120. ### Agent Activation
  121. For complex domain-specific tasks, consider activating a specialist agent:
  122. - `dotnet-csharp-concurrency-specialist` - Race conditions, deadlocks, thread safety
  123. - `dotnet-security-reviewer` - Security audit, OWASP compliance
  124. - `dotnet-performance-analyst` - Profiling, benchmarking
  125. - `dotnet-blazor-specialist` - Blazor architecture
  126. - `dotnet-testing-specialist` - Test strategy design
  127. ```
  128. ---
  129. ## Specialized Agents
  130. Agents are AI personas with deep domain expertise. They're invoked automatically when Claude Code detects relevant tasks.
  131. | Agent | Expertise |
  132. |-------|-----------|
  133. | **dotnet-architect** | Architecture patterns, framework choices, design patterns |
  134. | **dotnet-csharp-concurrency-specialist** | Race conditions, deadlocks, thread safety, synchronization |
  135. | **dotnet-security-reviewer** | OWASP compliance, secrets exposure, cryptographic misuse |
  136. | **dotnet-blazor-specialist** | Blazor Server/WASM/Hybrid/Auto components, state, auth |
  137. | **dotnet-uno-specialist** | Uno Platform, MVUX patterns, Toolkit controls, MCP |
  138. | **dotnet-maui-specialist** | .NET MAUI, platform-specific development, Native AOT |
  139. | **dotnet-performance-analyst** | Profiling data, benchmark results, GC behavior |
  140. | **dotnet-benchmark-designer** | BenchmarkDotNet benchmarks, measurement methodology |
  141. | **dotnet-docs-generator** | Mermaid diagrams, XML docs, GitHub-native docs |
  142. | **dotnet-async-performance-specialist** | ValueTask correctness, ConfigureAwait, ThreadPool tuning |
  143. | **dotnet-aspnetcore-specialist** | Middleware, DI patterns, minimal APIs, request pipeline |
  144. | **dotnet-testing-specialist** | Test pyramids, unit vs integration, test data management |
  145. | **dotnet-cloud-specialist** | .NET Aspire, AKS deployment, distributed tracing |
  146. | **dotnet-code-review-agent** | Multi-dimensional code review |
  147. | **dotnet-concurrency-specialist** | Threading, async/await, race conditions |
  148. | **docfx-specialist** | DocFX builds, API documentation, markdown linting |
  149. ---
  150. ## Skills Library
  151. ### Core C# Language
  152. Modern C# patterns for clean, performant code.
  153. | Skill | Description |
  154. |-------|-------------|
  155. | **csharp-coding-standards** | Records, pattern matching, nullable types, value objects, naming conventions, file organization, analyzer enforcement |
  156. | **csharp-concurrency-patterns** | Decision framework for async/await, Channels, locks, SemaphoreSlim, Interlocked, ConcurrentDictionary |
  157. | **csharp-api-design** | API surface design, parameter ordering, return types, error reporting, versioning |
  158. | **csharp-type-design-performance** | Sealed classes, readonly structs, Span<T>, Memory<T>, FrozenDictionary |
  159. | **dotnet-csharp-modern-patterns** | C# 12+ features, primary constructors, collection expressions |
  160. | **dotnet-csharp-async-patterns** | Async/await, Task, ValueTask, cancellation, ConfigureAwait |
  161. | **dotnet-csharp-source-generators** | Source generator authoring, incremental generators |
  162. | **dotnet-csharp-code-smells** | Anti-pattern detection and refactoring |
  163. | **dotnet-roslyn-analyzers** | Custom analyzer development |
  164. | **dotnet-linq-optimization** | LINQ performance, deferred execution |
  165. | **dotnet-io-pipelines** | System.IO.Pipelines for high-performance I/O |
  166. | **dotnet-native-interop** | P/Invoke, interop patterns |
  167. ### Architecture
  168. Enterprise architecture patterns and practices.
  169. | Skill | Description |
  170. |-------|-------------|
  171. | **dotnet-architecture-patterns** | Clean architecture, vertical slice, modular monolith |
  172. | **dotnet-solid-principles** | SOLID in practice |
  173. | **dotnet-domain-modeling** | DDD patterns, aggregates, domain events |
  174. | **dotnet-messaging-patterns** | Message queues, event-driven architecture |
  175. | **dotnet-structured-logging** | Serilog, structured logging patterns |
  176. | **dotnet-aspire-patterns** | .NET Aspire orchestration |
  177. ### ASP.NET Core
  178. Web application patterns.
  179. | Skill | Description |
  180. |-------|-------------|
  181. | **middleware-patterns** | Pipeline ordering, custom middleware, IExceptionHandler |
  182. | **razor-pages-patterns** | Page models, validation, anti-forgery, routing |
  183. | **validation-patterns** | FluentValidation, DataAnnotations, IValidateOptions<T> |
  184. | **exception-handling** | ProblemDetails, global handlers |
  185. | **caching-strategies** | Output caching, Redis, HybridCache |
  186. | **rate-limiting** | Request throttling, sliding window |
  187. | **security-headers** | CSP, HSTS, CORS |
  188. | **background-services** | BackgroundService, IHostedService, outbox, graceful shutdown |
  189. | **signalr-integration** | Real-time communication |
  190. ### Data Access
  191. Database patterns that scale.
  192. | Skill | Description |
  193. |-------|-------------|
  194. | **efcore-patterns** | DbContext lifecycle, NoTracking, query splitting, migrations, interceptors, compiled queries |
  195. | **database-performance** | N+1 prevention, read/write separation |
  196. | **dotnet-data-access-strategy** | EF Core vs Dapper vs ADO.NET |
  197. ### Security
  198. Security best practices for .NET applications.
  199. | Skill | Description |
  200. |-------|-------------|
  201. | **dotnet-security-owasp** | OWASP Top 10 for .NET |
  202. | **dotnet-secrets-management** | Secret storage, Azure Key Vault |
  203. | **dotnet-cryptography** | Encryption, hashing, key management |
  204. | **asp-net-core-identity-patterns** | Authentication, authorization, MFA |
  205. | **data-protection** | ASP.NET Core Data Protection API |
  206. ### Testing
  207. Comprehensive testing strategies.
  208. | Skill | Description |
  209. |-------|-------------|
  210. | **dotnet-testing-strategy** | Test pyramid, unit vs integration |
  211. | **dotnet-xunit** | xUnit patterns, fixtures |
  212. | **testcontainers** | Docker-based integration tests |
  213. | **snapshot-testing** | Verify library, custom converters, CI workflow |
  214. | **dotnet-playwright** | E2E browser testing |
  215. | **crap-analysis** | CRAP scores, coverage thresholds |
  216. ### Performance
  217. Performance optimization and profiling.
  218. | Skill | Description |
  219. |-------|-------------|
  220. | **dotnet-benchmarkdotnet** | Benchmark design, measurement |
  221. | **dotnet-performance-patterns** | Allocation reduction, optimization |
  222. | **dotnet-profiling** | Profiler usage, hotspots |
  223. | **dotnet-gc-memory** | GC modes, LOH, memory pressure |
  224. ### Native AOT
  225. Native AOT compilation and optimization.
  226. | Skill | Description |
  227. |-------|-------------|
  228. | **dotnet-native-aot** | AOT compilation, constraints |
  229. | **dotnet-trimming** | Size optimization, linker |
  230. | **dotnet-aot-wasm** | WASM AOT with Blazor |
  231. ### UI Frameworks
  232. Desktop and web UI frameworks.
  233. | Skill | Description |
  234. |-------|-------------|
  235. | **dotnet-blazor-patterns** | Server/WASM/Hybrid patterns |
  236. | **dotnet-blazor-components** | Component lifecycle, rendering |
  237. | **dotnet-blazor-auth** | Blazor authentication |
  238. | **dotnet-maui-development** | Cross-platform mobile/desktop |
  239. | **dotnet-winui** | Windows App SDK, WinUI 3 |
  240. | **dotnet-wpf-modern** | Modern WPF patterns |
  241. | **dotnet-accessibility** | Accessibility standards |
  242. | **bootstrap5-ui** | Bootstrap 5 integration |
  243. ### CI/CD
  244. Continuous integration and deployment.
  245. | Skill | Description |
  246. |-------|-------------|
  247. | **dotnet-gha-patterns** | GitHub Actions patterns |
  248. | **dotnet-gha-build-test** | Build/test workflows |
  249. | **dotnet-gha-publish** | NuGet/container publishing |
  250. | **dotnet-ado-patterns** | Azure DevOps pipelines |
  251. ### Deployment
  252. Deployment and infrastructure.
  253. | Skill | Description |
  254. |-------|-------------|
  255. | **fly-io** | Fly.io deployment, Machines, Volumes |
  256. | **dotnet-containers** | Docker for .NET |
  257. | **dotnet-container-deployment** | Container orchestration |
  258. ### Specialized Frameworks
  259. Domain-specific frameworks.
  260. | Skill | Description |
  261. |-------|-------------|
  262. | **csharp-wolverinefx** | Messaging, HTTP, Marten event sourcing |
  263. | **aspire-configuration** | .NET Aspire configuration |
  264. | **aspire-integration-testing** | Aspire testing |
  265. ### Meta-Skills
  266. Skills for AI assistants.
  267. | Skill | Description |
  268. |-------|-------------|
  269. | **slopwatch** | LLM anti-pattern detection, CLI usage |
  270. | **dotnet-agent-gotchas** | Common AI mistakes in .NET |
  271. | **dotnet-build-analysis** | Build output analysis |
  272. ---
  273. ## Key Principles
  274. These skills emphasize patterns that work in production:
  275. - **Immutability by default** - Records, readonly structs, value objects
  276. - **Type safety** - Nullable reference types, strongly-typed IDs
  277. - **Composition over inheritance** - No abstract base classes, sealed by default
  278. - **Performance-aware** - Span&lt;T&gt;, pooling, deferred enumeration
  279. - **Testable** - DI everywhere, pure functions, explicit dependencies
  280. - **No magic** - No AutoMapper, no reflection-heavy frameworks
  281. ---
  282. ## Repository Structure
  283. ```
  284. dotnet-skills/
  285. ├── .claude-plugin/
  286. │ └── plugin.json # Plugin manifest
  287. ├── agents/ # 16 specialized agents
  288. └── skills/ # 167 skills
  289. ```
  290. ---
  291. ## Acknowledgements
  292. - Skills merged from [dotnet-artisan](https://github.com/novotnyllc/dotnet-artisan) by Claire Novotny LLC
  293. - Original patterns from production systems
  294. ---
  295. ## Author
  296. Created by [Aaron Stannard](https://aaronstannard.com/) ([@Aaronontheweb](https://github.com/Aaronontheweb))
  297. ## License
  298. MIT License - Copyright (c) 2025 Aaron Stannard

Ratings and comments

Sign in to rate this skill.

Sign in

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