Help us improve
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
Share bugs, ideas, or general feedback.
By wshaddix
Debug .NET concurrency issues like deadlocks, race conditions, and threading bugs with expert analysis of Tasks, async patterns, and synchronization. Validate Akka.NET docs via DocFX with markdown linting, API references, config checks, and error-free builds. Discover and install specialized skills for React, testing, or deployment using npx CLI.
npx claudepluginhub wshaddix/dotnet-skillsCreate a new use case architecture plan
Review and finalize the use case implementation plan
Asks the AI Agent to report it's findings on the previous use case implementation coding session
Instructs AI Agent to read the use case, the implementation plan and write the code
Reviews the deployment process for any issues and/or lessons learned
Expert in DocFX documentation system, markdown formatting, and Akka.NET documentation standards. Handles DocFX-specific syntax, API references, build validation, and compliance with project documentation guidelines. Integrates markdownlint and DocFX compilation checks.
Analyzes .NET project context, requirements, and constraints to recommend architecture approaches, framework choices, and design patterns. Triggers on: what framework to use, how to structure a project, recommend an approach, architecture review.
WHEN analyzing ASP.NET Core middleware, request pipelines, minimal API design, DI lifetime selection, or diagnostic scenarios. WHEN NOT handling Blazor/Razor (use dotnet-blazor-specialist), security auditing (use dotnet-security-reviewer), or async internals (use dotnet-async-performance-specialist).
WHEN analyzing async/await performance, ValueTask correctness, ConfigureAwait decisions, IO.Pipelines, ThreadPool tuning, or Channel selection in .NET code. WHEN NOT profiling interpretation (use dotnet-performance-analyst) or thread sync bugs (use dotnet-csharp-concurrency-specialist).
WHEN designing .NET benchmarks, reviewing benchmark methodology, or validating measurement correctness. Avoids dead code elimination, measurement bias, and common BenchmarkDotNet pitfalls. Triggers on: design a benchmark, review benchmark, benchmark pitfalls, how to measure, memory diagnoser setup.
Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.
Production-grade patterns for ASP.NET Core Identity in Razor Pages and web apps. Covers setup, customization, security hardening, auth flows, roles/claims, external providers, and integration best practices for .NET 8+ / .NET 9+. Use when implementing authentication and authorization in ASP.NET Core applications, configuring ASP.NET Core Identity, setting up external login providers, or managing roles and claims.
Configure Aspire AppHost to emit explicit app config via environment variables while keeping app code free of Aspire clients and service discovery. Use when wiring AppHost resources to application configuration, ensuring production configuration is transparent and portable outside of Aspire, or avoiding Aspire client packages inside application code.
Write integration tests using .NET Aspire's testing facilities with xUnit. Covers test fixtures, distributed application setup, endpoint discovery, and patterns for testing ASP.NET Core apps with real dependencies. Use when writing integration tests for .NET Aspire applications, testing ASP.NET Core apps with real database connections, or verifying service-to-service communication in distributed applications.
Test email sending locally using Mailpit with .NET Aspire. Captures all outgoing emails without sending them. View rendered HTML, inspect headers, and verify delivery in integration tests. Use when testing email delivery locally without sending real emails, setting up email infrastructure in .NET Aspire, or writing integration tests that verify emails are sent.
Uses power tools
Uses Bash, Write, or Edit tools
Runs pre-commands
Contains inline bash commands via ! syntax
Bash prerequisite issue
Share bugs, ideas, or general feedback.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge.
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Comprehensive .NET development skills and agents for Claude Code - covering C#, F#, Akka.NET, Aspire, testing frameworks, and specialized tools
Comprehensive .NET backend development with C#, ASP.NET Core, Entity Framework Core, and Dapper for production-grade applications
The definitive Claude Code companion for .NET developers. 47 skills, 10 agents, 16 commands, 10 rules, 5 templates, 15 MCP tools, 7 hooks for modern .NET 10 / C# 14.
Comprehensive .NET 10, Blazor, ASP.NET Core, C#, and Syncfusion expert plugin for building modern web apps, microservices, and cloud-native solutions
Everyday maintenance automation and one-shot upgrade skills for .NET 10+, C# 14 applications with Aspire MCP integration
No description provided.
Uses bash pre-commands but Bash not in allowed tools
Uses bash pre-commands but Bash not in allowed tools
Share bugs, ideas, or general feedback.
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.
This plugin works with multiple AI coding assistants that support skills/agents.
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
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/
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/
Copy the following snippet into your project's AGENTS.md file to enable intelligent skill routing:
## .NET Skill Library
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.
### Skill Routing by Task Type
**Writing C# Code:**
- `modern-csharp-coding-standards` - Records, pattern matching, immutability, value objects, async patterns
- `csharp-concurrency-patterns` - Choosing between async/await, Channels, locks, synchronization primitives
- `csharp-api-design` - API surface design, versioning, backward compatibility
- `csharp-type-design-performance` - Sealed classes, readonly structs, Span<T>, Memory<T>
**Entity Framework Core:**
- `efcore-patterns` - DbContext lifecycle, NoTracking, query splitting, migrations, interceptors
- `database-performance` - N+1 prevention, read/write separation, query optimization
**ASP.NET Core Web:**
- `middleware-patterns` - Pipeline ordering, custom middleware, exception handling
- `razor-pages-patterns` - Page models, validation, anti-forgery, routing
- `validation-patterns` - FluentValidation, DataAnnotations, custom validators
- `exception-handling` - ProblemDetails, global handlers, error responses
- `caching-strategies` - Output caching, Redis, HybridCache (.NET 9+)
- `rate-limiting` - Request throttling, sliding window, concurrency limits
- `security-headers` - CSP, HSTS, CORS, security middleware
**Background Processing:**
- `background-services` - BackgroundService, IHostedService, outbox pattern, graceful shutdown
- `dotnet-channels` - Producer/consumer, bounded channels, backpressure
**Dependency Injection:**
- `microsoft-extensions-dependency-injection` - Service lifetimes, keyed services, factory patterns
- `microsoft-extensions-configuration` - IOptions, configuration providers, secrets
**Testing:**
- `dotnet-testing-strategy` - Test pyramid, unit vs integration decisions
- `dotnet-xunit` - xUnit patterns, fixtures, theory data
- `testcontainers` - Docker-based integration tests, database fixtures
- `snapshot-testing` - Verify library, approval testing
- `dotnet-playwright` - E2E browser testing
- `crap-analysis` - CRAP scores, coverage analysis
**Performance:**
- `dotnet-benchmarkdotnet` - Benchmark design, measurement methodology
- `dotnet-performance-patterns` - Allocation reduction, GC optimization
- `dotnet-profiling` - Profiler usage, hotspot identification
- `dotnet-gc-memory` - GC modes, memory pressure, Large Object Heap
**Native AOT:**
- `dotnet-native-aot` - AOT compilation, publishing, constraints
- `dotnet-trimming` - Size optimization, linker configuration
- `dotnet-aot-wasm` - WASM AOT with Blazor
**Security:**
- `dotnet-security-owasp` - OWASP Top 10 for .NET
- `dotnet-cryptography` - Encryption, hashing, key management
- `dotnet-secrets-management` - Secret storage, Azure Key Vault, user secrets
- `asp-net-core-identity-patterns` - Authentication, authorization, MFA