aaronontheweb/dotnet-skills
34 skills16.2k installs37.2k starsGitHub
Install
npx skills add https://github.com/aaronontheweb/dotnet-skillsSkills in this repo
1Modern Csharp Coding StandardsThe modern-csharp-coding-standards skill guides agents toward C# 12+ idioms for libraries and services. Core principles include immutability with records and init-only properties, nullable reference types, switch expressions, async APIs with cancellation, zero-allocation Span and Memory usage, and composition over inheritance. Reference files expand value objects, performance patterns, Result-based error handling, and anti-patterns such as reflection overuse. Examples show readonly record structs, discriminated unions, pipeline-friendly APIs, and testing guidance. Use when writing new C# code, refactoring legacy classes, designing public APIs, or optimizing hot paths in backend services.1.7kinstalls2Csharp Concurrency PatternsThe csharp-concurrency-patterns skill is designed for choosing the right concurrency abstraction in .NET - from async/await for I/O to Channels for producer/consumer to Akka.NET for stateful entity management. Avoid locks and. Most concurrency problems can be solved with async/await. Only reach for more sophisticated tools when you have a specific need that async/await can't address cleanly. Invoke when the user asks about csharp concurrency patterns or related SKILL.md workflows.1.3kinstalls3Efcore PatternsThe efcore-patterns skill is designed for entity Framework Core best practices including NoTracking by default, query splitting for navigation collections, migration management, dedicated migration services, and common. NoTracking by Default - Most queries are read-only; opt-in to tracking 2. Never Edit Migrations Manually - Always use CLI commands 3. Invoke when the user asks about efcore patterns or related SKILL.md workflows.1.3kinstalls4Dotnet Project Structuredotnet-project-structure is a .NET agent skill from aaronontheweb/dotnet-skills for designing solution layouts when starting or refactoring multi-service C# codebases. It guides where to place application, domain, infrastructure, and shared library projects, how to wire .csproj references without circular dependencies, and how to add test projects that mirror production boundaries. Use it at greenfield setup or when a monolith outgrows a single project and needs bounded contexts split into class libraries and testable units. The skill focuses on folder and project topology—not runtime deployment—so teams get a consistent .sln structure before writing feature code.495installs5Type Design Performancetype-design-performance is a non-invocable reference skill in Aaronontheweb/dotnet-skills, a Claude Code plugin with 30 skills and 5 specialized agents for production .NET development. It teaches five core principles: seal classes by default for JIT devirtualization, prefer readonly structs for small immutable value types, use static pure functions, defer enumeration until materialization is required, and return immutable collections from API boundaries. Guidance covers choosing between class, struct, and record, avoiding defensive copies, and selecting performant collection types on hot paths. The dotnet-skills README routes C# performance reviews to type-design-performance alongside modern-csharp-coding-standards and api-design. Reach for it when designing new types, reviewing allocation-heavy APIs, or refactoring enumerables that trigger excess GC collections in .NET services.485installs6Dependency Injection Patternsdependency-injection-patterns is a Claude Code skill from aaronontheweb/dotnet-skills by Aaron Stannard for structuring Microsoft.Extensions.DependencyInjection registrations in ASP.NET Core. Instead of hundreds of lines in Program.cs, the skill groups related services into Add{Feature}Services extension methods placed in {Feature}ServiceCollectionExtensions.cs beside each feature. Developers reach for it when production and test environments must share wiring via WebApplicationFactory, Akka.Hosting.TestKit, or standalone ServiceCollection overrides. Advanced patterns cover conditional registration, factory-based services, keyed services, layered composition, and Akka.NET actor scope management.482installs7Api Designapi-design is an agent skill in aaronontheweb/dotnet-skills for designing stable, compatible public APIs before .NET implementation begins. The SKILL.md defines three compatibility types—API/source, binary, and wire—and applies extend-only design principles for NuGet packages and distributed systems. Developers reach for api-design when creating new public surfaces, planning wire format changes, implementing versioning strategies, or reviewing pull requests for breaking changes. The skill is marked invocable: false, meaning it guides design and review rather than executing commands. Use it early so REST or RPC contracts, error models, and auth boundaries stay consistent across .NET services.468installs8Database Performancedatabase-performance is an aaronontheweb/dotnet-skills agent skill focused on high-performance database access in .NET services. It promotes separating read and write models, batching to avoid N+1 queries, retrieving only required columns, applying row limits, using EF Core AsNoTracking for reads, and avoiding application-side joins. The skill works with both EF Core and Dapper and tags cover cqrs, performance, and patterns. Developers invoke it when designing data layers, profiling slow endpoints, or choosing between ORM and micro-ORM approaches under load. It is marked invocable: false in the manifest, meaning it guides design reviews and refactors rather than auto-running as a standalone command. The outcome is leaner queries, correct indexing guidance, and connection-pool-aware access patterns that prevent timeouts at ship time.459installs9Package Managementpackage-management is an Aaron Ontheweb dotnet-skills agent skill encoding NuGet best practices for developers bootstrapping or upgrading .NET solutions. The golden rule is never edit package XML by hand—always use dotnet add, dotnet remove, and dotnet list commands so restore graphs stay consistent. The skill covers Central Package Management setup with shared version variables across multi-project solutions, conflict troubleshooting when restore fails, and coordinated version pinning for related package families. Developers reach for package-management when introducing libraries to new services, migrating to CPM, or fixing NU1107-style dependency clashes after framework upgrades. Instructions emphasize shared version variables in Directory.Packages.props rather than scattering versions per csproj. The skill suits backend and tooling engineers maintaining SDK-style projects who want agents to follow deterministic CLI workflows instead of hallucinated XML edits that break CI restore steps.441installs10Ilspy Decompileilspy-decompile is an aaronontheweb dotnet-skills skill that guides agents through .NET assembly decompilation using ILSpy command-line tooling. Prerequisites include the .NET SDK and ilspycmd via `dnx ilspycmd` or `dotnet tool install --global ilspycmd`. Developers use ilspy-decompile to reveal how NuGet packages, framework libraries, or legacy DLLs behave internally—tracing bugs, verifying API contracts, and mapping dependencies without original repositories. The skill fits integration debugging, security reviews of opaque binaries, and learning undocumented surface areas in compiled .NET code. Agents invoke it when questions arise about compiled behavior that docs and public source cannot answer, producing readable C#-like output from binaries.433installs11Microsoft Extensions Configurationmicrosoft-extensions-configuration is an agent skill in aaronontheweb/dotnet-skills, part of a plugin with 30 skills and 5 specialized agents for professional .NET development. The SKILL.md documents 5 configuration patterns: basic Options binding from appsettings.json, Data Annotations validation with [Required] and [Range], IValidateOptions<T> for cross-property and conditional rules, IOptions vs IOptionsSnapshot vs IOptionsMonitor lifetime choices, and PostConfigure normalization before validation. Registration emphasizes AddOptions<T>().BindConfiguration().ValidateDataAnnotations().ValidateOnStart() so misconfiguration fails at startup rather than deep in business logic. Anti-patterns warn against injecting IConfiguration directly, validating in service constructors, and throwing inside IValidateOptions instead of returning ValidateOptionsResult.Fail. An advanced-patterns.md reference covers named options and production AkkaSettings examples. Use microsoft-extensions-configuration when wiring new .NET service configuration or eliminating silent config defaults.431installs12Crap Analysiscrap-analysis is an aaronontheweb dotnet-skills skill that calculates CRAP (Change Risk Anti-Patterns) scores using the formula Complexity × (1 − Coverage)² to expose risky .NET methods. It expects OpenCover-format coverage feeds and ReportGenerator Risk Hotspots output showing cyclomatic complexity alongside untested paths. Developers invoke crap-analysis while evaluating quality before changes, setting CI coverage thresholds, or deciding which classes deserve tests first. The skill supports pre-merge reviews, release readiness checks, and pipeline gates where high complexity with low coverage signals refactor or test work. It is invocable directly in agent workflows when coverage artifacts already exist or when agents help configure collection for a .NET solution.425installs13Serializationserialization is a Claude Code skill from the Aaronontheweb/dotnet-skills plugin that guides C# developers through choosing and configuring JSON or binary serializers for .NET APIs, messaging, and persistence. The skill compares schema-based formats—Protocol Buffers, MessagePack, and System.Text.Json with AOT source generators—against reflection-based options like Newtonsoft.Json, with explicit guidance on when each fits REST APIs, gRPC, actor systems, event sourcing, and caching. It includes ready-to-adapt code for JsonSerializerContext, .proto schemas, MessagePack contracts, ASP.NET Core HttpJsonOptions, and a six-row Newtonsoft-to-System.Text.Json migration table covering polymorphism with JsonDerivedType. Developers reach for serialization when migrating off Newtonsoft.Json, publishing Native AOT binaries, designing wire-compatible distributed payloads, or optimizing hot-path serialize/deserialize throughput across five compared formats. The skill is non-invocable guidance (invocable: false) within a 30-skill, 5-agent dotnet-skills library built for production .NET patterns.423installs14Playwright Blazor Testingplaywright-blazor-testing is a .NET-focused agent skill from aaronontheweb/dotnet-skills for writing and running Playwright end-to-end tests against Blazor applications. It helps developers validate interactive UI flows—component rendering, client-side routing, form submissions, and browser events—that unit tests often miss in WebAssembly or Server Blazor projects. The skill fits teams shipping Blazor SPAs or hybrid apps who need repeatable browser automation in CI rather than manual click-through checks. Agents invoke it when Blazor pages change, new routes land, or a release candidate needs regression coverage across Chromium-based browsers. It complements xUnit or bUnit coverage by exercising the full rendered stack. Catalog metadata describes Playwright-driven Blazor E2E automation; verify the repo skill file matches this id before relying on bundled scripts or commands.419installs15Dotnet Slopwatchdotnet-slopwatch is an aaronontheweb/dotnet-skills agent skill integrating the Slopwatch.Cmd .NET tool to detect LLM reward hacking in C# changes. The skill runs after every edit to .cs, .csproj, Directory.Build.props, Directory.Packages.props, and test files, comparing findings against a .slopwatch/baseline.json so only newly introduced slop fails. Six detection rules span SW001 disabled tests through SW006 CPM bypass patterns including empty catch blocks and NoWarn project slop. Install via dotnet tool install --global Slopwatch.Cmd, initialize with slopwatch init, then run slopwatch analyze or slopwatch analyze --fail-on warning. The skill supports Claude Code PostToolUse hooks and CI pipelines that fail builds when agents silence warnings or skip tests instead of fixing root causes.416installs16Testcontainers Integration Teststestcontainers-integration-tests is an agent skill from aaronontheweb/dotnet-skills that guides Claude to write and run .NET integration tests using Testcontainers. Developers use it to start real databases, message queues, and dependent services in ephemeral Docker containers during test runs instead of mocks or shared staging environments. The skill targets faithful pre-release validation for .NET APIs and services. Reach for it when xUnit or NUnit suites need isolated, reproducible integration coverage against actual infrastructure components.400installs17Dotnet Local Toolsdotnet-local-tools is an agent skill from aaronontheweb/dotnet-skills for managing .NET local tools through a repository-scoped manifest at `.config/dotnet-tools.json`. The workflow starts with `dotnet new tool-manifest`, adds tools via `dotnet tool install`, and restores them everywhere with `dotnet tool restore`, keeping formatters like CSharpier, analyzers, DocFX, dotnet-ef, ReportGenerator, and incrementalist pinned per project. It documents manifest fields such as `isRoot`, exact versions, and `rollForward: false` for reproducible builds, plus GitHub Actions and Azure Pipelines snippets that run restore before doc generation, coverage reporting, or EF migrations. Reach for dotnet-local-tools when onboarding a .NET repo, eliminating global tool version conflicts, or aligning local developer setups with CI/CD tool versions.398installs18Mjml Email Templatesmjml-email-templates is a .NET-focused Claude skill for building responsive email templates with MJML markup that compiles to cross-client HTML for Outlook, Gmail, and Apple Mail. It includes a template renderer, layout patterns, and variable substitution for transactional flows such as signup, password reset, invoices, and notifications. Related skills reference Mailpit integration for local testing and snapshot verification for rendered HTML. Developers reach for mjml-email-templates when adding MJML-based email rendering to ASP.NET or .NET services instead of hand-writing table-heavy HTML for every client quirk.394installs19Aspire Integration Testingaspire-integration-testing is an agent skill from aaronontheweb/dotnet-skills that teaches robust integration testing for .NET Aspire distributed applications using xUnit. It centers on DistributedApplicationTestingBuilder from the Aspire.Hosting.Testing NuGet package, which launches the full AppHost with real infrastructure (SQL Server, Redis, message queues) in containers instead of mocks. Six core principles cover real dependencies, dynamic port binding (127.0.0.1:0), IAsyncLifetime fixture lifecycle, runtime endpoint discovery, xUnit collection parallelization, and health-check waits via ResourceNotifications. Advanced patterns include Playwright UI tests, Respawn database resets, conditional resource configuration, and CI/CD integration. Developers reach for this skill when testing microservice communication, ASP.NET Core apps with real databases, or Aspire-orchestrated multi-service deployments before release.376installs20Aspire Service Defaultsaspire-service-defaults is an agent skill from aaronontheweb/dotnet-skills for .NET Aspire distributed applications. The skill creates a shared ServiceDefaults project that centralizes OpenTelemetry logging, tracing, and metrics, health check configuration, HttpClient resilience policies, and service discovery across every microservice in an Aspire app host solution. It gives each service consistent observability and production baselines instead of duplicating boilerplate Program.cs configuration. Developers reach for aspire-service-defaults when bootstrapping Aspire-based microservices that need uniform telemetry, health endpoints, and resilient HTTP clients from day one.361installs21Aspire Configurationaspire-configuration is an agent skill from aaronontheweb/dotnet-skills for wiring .NET Aspire AppHost projects to application configuration. It teaches developers to let AppHost own Aspire Hosting packages and emit connection strings, feature toggles, and service endpoints as environment variables that app code reads through standard IConfiguration—without pulling Aspire client or service-discovery NuGet packages into application assemblies. Teams reach for aspire-configuration when Aspire-based repos need portable, transparent production settings for local dev, containers, and cloud targets. Core principles include infrastructure-in-AppHost, configuration-via-env-vars, and dev/test feature toggles that do not fork application code paths.350installs22Snapshot TestingTeaches .NET snapshot testing workflows for capturing and comparing structured outputs so teams quickly spot unintended changes in APIs, rendered content, and serialization results without writing exhaustive assertion permutations.350installs23Akka Net Best Practicesakka-net-best-practices distills production guidance for Akka.NET applications, including actor design, testing, clustering, persistence, and performance habits in .NET backends. It helps teams avoid common pitfalls and ship maintainable message-driven services aligned with the broader dotnet-skills repository.348installs24Playwright Ci Cachingplaywright-ci-caching is an agent skill from aaronontheweb/dotnet-skills for speeding up Playwright end-to-end test pipelines. Playwright browsers weigh roughly 400MB and download on every CI run by default, adding 1-2 minutes of overhead and wasting bandwidth. The skill shows how to cache browser binaries in GitHub Actions and Azure DevOps with automatic invalidation when the Playwright version changes. .NET teams reach for playwright-ci-caching when E2E suites are correct but PR builds feel slow due to repeated browser installs. The result is reliable faster feedback on every pull request without skipping browser updates when versions bump.340installs25Skills Index Snippetsskills-index-snippets is a Skill Development meta skill from aaronontheweb/dotnet-skills for creating and maintaining AGENTS.md and CLAUDE.md snippet indexes that route tasks to the right dotnet-skills skills and agents. The skill covers adding, removing, or renaming repository skills, updating .claude-plugin/plugin.json, and producing copy-paste snippets for downstream repos including OpenCode and Claude Code. It supports compact Vercel-style compressed indexes that stay always-on to improve skill utilization. Developers reach for skills-index-snippets when dotnet-skills grows or changes and agent routing tables need to stay accurate without manual guesswork.340installs26Akka Hosting Actor Patternsakka-hosting-actor-patterns is a .NET skill from aaronontheweb/dotnet-skills for developers building entity actors with Akka.Hosting in distributed C# services. The skill covers GenericChildPerEntityParent, message extractors, cluster sharding abstractions, akka-reminders, and ITimeProvider patterns that work in both local unit tests and clustered production modes. Developers reach for akka-hosting-actor-patterns when domain entities such as users, orders, or invoices need actors with supervision, scheduled tasks, and Akka.Hosting extension registration. The skill is marked non-invocable and serves as a reference workflow for reusable actor configuration across test and production topologies. Use it when Akka.NET hosting complexity spans sharding, reminders, and lifecycle management. Skip it for simple ASP.NET CRUD APIs, non-.NET stacks, or projects not using Akka.NET actor models.335installs27Dotnet Devcert Trustdotnet-devcert-trust is a .NET skill for HTTPS development certificate trust on Linux. It covers the full lifecycle from dotnet dev-certs https generation through system CA bundle inclusion, with distro-specific steps for Ubuntu, Fedora, Arch, and WSL2. Developers invoke it when Redis TLS fails with UntrustedRoot in Aspire, dotnet dev-certs https --check --trust returns exit code 7, localhost HTTPS breaks after dotnet dev-certs https --clean, or a new Linux workstation needs trusted dev certs for browser, API client, and service-to-service testing. The skill is non-invocable metadata-wise but provides targeted remediation instead of generic TLS debugging.335installs28Akka Net Testing Patternsakka-net-testing-patterns is an agent skill from aaronontheweb/dotnet-skills for testing actor-based .NET systems built with Akka.NET. It guides developers through TestKit usage, message-flow assertions, persistence plugin testing, and cluster behavior verification before shipping distributed services. Teams reach for this skill when unit tests alone cannot catch ordering, supervision, or remoting bugs in actor hierarchies. The skill encodes idiomatic Akka.NET test fixtures—TestProbe patterns, async await conventions, multi-node test considerations, and persistence recovery scenarios—so agents write tests that exercise real messaging semantics instead of mocking actors away.331installs29Akka Net Managementakka-net-management is a .NET distributed systems skill from aaronontheweb/dotnet-skills focused on operating Akka.NET clusters in production backend services. It guides cluster management setup, node discovery configuration, and health coordination patterns so actor-based .NET services scale reliably across nodes. Developers reach for akka-net-management when implementing Akka.NET cluster bootstrapping, remoting topology, split-brain mitigation concerns, or health probes for actor systems during backend implementation of high-availability microservices.329installs30Mailpit Integrationmailpit-integration is a .NET-focused skill from aaronontheweb/dotnet-skills that shows how to capture all outgoing emails locally using Mailpit alongside .NET Aspire. Developers use it when testing registration, password reset, and notification templates, inspecting rendered HTML, verifying headers, and asserting delivery inside integration tests without touching production SMTP. The skill is marked non-invocable as a standalone entry but documents when to apply Mailpit during Aspire service setup and email debugging. It references related skills aspnetcore/mjml-email-templates for MJML authoring and testing/verify-email-snapshots for rendered HTML snapshot tests. Reach for mailpit-integration whenever .NET services send transactional email and the team needs a repeatable local inbox plus test assertions before CI promotion.326installs31Verify Email SnapshotsVerify Email Snapshots is an agent skill from aaronontheweb/dotnet-skills that snapshot-tests transactional email HTML and text using the Verify library in .NET applications. The workflow validates rendered output against approved baselines, supports MJML-compiled templates and other email renderers, and produces visual diffs suitable for code review. Developers reach for Verify Email Snapshots when personalization tokens, links, or layout changes risk silent regressions in customer emails. The skill pairs with MJML template authoring and local Mailpit delivery testing elsewhere in the dotnet-skills collection.323installs32Akka Net Aspire Configurationakka-net-aspire-configuration is an aaronontheweb/dotnet-skills skill for running Akka.NET actor systems and clusters within .NET Aspire application hosts. Developers use it when microservices need actor-model concurrency—message-driven workers, stateful grains, or clustered sharding—while still benefiting from Aspire service defaults, service discovery, health checks, and environment-specific configuration. The skill guides wiring Akka.NET HOCON settings, cluster seed nodes, and health probe endpoints so Aspire dashboards reflect actor system readiness alongside ASP.NET Core services. Reach for akka-net-aspire-configuration when migrating standalone Akka.NET deployments into Aspire-orchestrated local and cloud environments without losing cluster formation or discovery semantics. Use it during backend build when distributed .NET services combine Aspire hosting with Akka.NET reliability patterns for message processing, stateful actors, or multi-node clustering across staging and production profiles.317installs33Marketplace Publishingmarketplace-publishing is a release workflow skill from aaronontheweb/dotnet-skills for maintainers shipping skills and agents to the dotnet-skills Claude Code marketplace. The skill covers repository structure under .claude-plugin/, updating marketplace.json and plugin.json registries, content validation, and release tagging via .github/workflows/release.yml automation. Developers reach for marketplace-publishing when adding new Akka.NET or other .NET skills, updating plugin metadata, or cutting a marketplace release. Output includes updated catalog files, validated plugin manifests, and tagged releases ready for user discovery and install.310installs34Opentelemetry Net InstrumentationExplains how to instrument .NET applications with OpenTelemetry for traces, metrics, and structured logs, wiring exporters and sampling so production services remain observable across dependencies.265installs