---
title: "Wes Shaddix (@wshaddix) skills · skilld"
canonical_url: "https://skilld.dev/gh/wshaddix"
meta:
  description: "167 agent skills written by Wes Shaddix on skilld."
  "og:description": "167 agent skills written by Wes Shaddix."
  "og:title": "Wes Shaddix on skilld"
---

`

![Avatar for Wes Shaddix](https://skilld.dev/_img/avatar?url=https%3A%2F%2Fgithub.com%2Fwshaddix.png)

# **Wes Shaddix**

[@wshaddix](https://github.com/wshaddix)person

167 skills 79 Atlanta, GA, USA Synced 2 months ago

[GitHub](https://github.com/wshaddix) [Website](https://wesshaddix.com)

## Skills

### [wshaddix/dotnet-skills](https://skilld.dev/gh/wshaddix/dotnet-skills)

167 skills 79

`npx skilld add wshaddix/dotnet-skills`

- [

  **/agent-browser**79

  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. /agent-browser by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/agent-browser)
- [

  **/asp-net-core-identity-patterns**79

  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. /asp-net-core-identity-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/asp-net-core-identity-patterns)
- [

  **/aspire-configuration**79

  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. /aspire-configuration by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/aspire-configuration)
- [

  **/aspire-integration-testing**79

  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. /aspire-integration-testing by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/aspire-integration-testing)
- [

  **/aspire-mailpit-integration**79

  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. /aspire-mailpit-integration by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/aspire-mailpit-integration)
- [

  **/aspire-service-defaults**79

  Create a shared ServiceDefaults project for Aspire applications. Centralizes OpenTelemetry, health checks, resilience, and service discovery configuration across all services. Use when building Aspire-based distributed applications, needing consistent observability across services, or configuring HttpClient resilience and service discovery. /aspire-service-defaults by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/aspire-service-defaults)
- [

  **/background-services**79

  Hosted services, background jobs, outbox patterns, and graceful shutdown handling for ASP.NET Core applications. Includes patterns for reliable job processing, distributed systems, and lifecycle management. Use when implementing background processing in ASP.NET Core applications, handling outbox patterns for reliable message delivery, or managing graceful service shutdown. /background-services by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/background-services)
- [

  **/bootstrap5-ui**79

  Production-grade Bootstrap 5.3 patterns for building modern, responsive web UIs in HTML and ASP.NET Core Razor Pages/Views. Use when creating or styling web pages, layouts, navigation, forms, cards, modals, tables, or any UI component with Bootstrap 5. Covers the grid system, responsive breakpoints, utility classes, color modes (dark/light), accessibility, and integration with ASP.NET Core tag helpers and Razor syntax. Trigger on any task involving Bootstrap CSS classes, responsive HTML layouts, Razor Page UI design, or front-end styling for .NET web applications. /bootstrap5-ui by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/bootstrap5-ui)
- [

  **/caching-strategies**79

  Comprehensive caching patterns for ASP.NET Core Razor Pages applications. Covers output caching, response caching, memory caching, distributed caching with Redis, cache invalidation strategies, and HybridCache (.NET 9+). Use when implementing caching in Razor Pages applications, choosing between memory and distributed caching, or optimizing application performance with caching. /caching-strategies by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/caching-strategies)
- [

  **/crap-analysis**79

  Analyze code coverage and CRAP (Change Risk Anti-Patterns) scores to identify high-risk code. Use OpenCover format with ReportGenerator for Risk Hotspots showing cyclomatic complexity and untested code paths. Use when evaluating code quality and test coverage before changes, identifying high-risk code that needs refactoring or testing, setting up coverage collection for a .NET project, or establishing coverage thresholds for CI/CD pipelines. /crap-analysis by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/crap-analysis)
- [

  **/csharp-api-design**79

  Design stable, compatible public APIs using extend-only design principles. Manage API compatibility, wire compatibility, versioning, naming conventions, parameter ordering, and return types for NuGet packages and distributed systems. Use when designing public APIs for NuGet packages or libraries, making changes to existing public APIs, planning wire format changes for distributed systems, or reviewing pull requests for breaking changes. /csharp-api-design by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/csharp-api-design)
- [

  **/csharp-coding-standards**79

  Write modern, high-performance C# code using records, pattern matching, value objects, async/await, Span\<T>/Memory\<T>, and best-practice API design patterns. Emphasizes functional-style programming with C# 12+ features. Use when writing new C# code or refactoring existing code, designing public APIs for libraries or services, optimizing performance-critical code paths, or building async/await-heavy applications. /csharp-coding-standards by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/csharp-coding-standards)
- [

  **/csharp-concurrency-patterns**79

  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. Covers both high-level abstractions and low-level synchronization primitives. Use when deciding how to handle concurrent operations in .NET, evaluating whether to use async/await, Channels, or Akka.NET, or managing state across multiple concurrent entities. /csharp-concurrency-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/csharp-concurrency-patterns)
- [

  **/csharp-scripts**79

  Run single-file C# programs as scripts for quick experimentation, prototyping, and concept testing. Use when the user wants to write and execute a small C# program without creating a full project. /csharp-scripts by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/csharp-scripts)
- [

  **/csharp-type-design-performance**79

  Design .NET types for performance. Covers struct vs class decision matrix, sealed by default, readonly structs, ref struct and Span/Memory selection, FrozenDictionary, ValueTask, and collection return types. Use when designing new types and APIs, reviewing code for performance issues, choosing between class, struct, and record, or working with collections and enumerables. /csharp-type-design-performance by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/csharp-type-design-performance)
- [

  **/csharp-wolverinefx**79

  Build .NET applications with WolverineFX for messaging, HTTP services, and event sourcing. Use when implementing command handlers, message handlers, HTTP endpoints with WolverineFx.HTTP, transactional outbox patterns, event sourcing with Marten, CQRS architectures, cascading messages, batch message processing, or configuring transports like RabbitMQ, Azure Service Bus, or Amazon SQS. /csharp-wolverinefx by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/csharp-wolverinefx)
- [

  **/data-protection**79

  ASP.NET Core Data Protection API patterns for encryption, key management, and secure data handling in web applications. Use when protecting sensitive data at rest or in transit, managing encryption keys in ASP.NET Core applications, or implementing secure token generation and validation. /data-protection by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/data-protection)
- [

  **/database-performance**79

  Database access patterns for performance. Separate read/write models, avoid N+1 queries, use AsNoTracking, apply row limits, and never do application-side joins. Works with EF Core and Dapper. Use when designing data access layers, optimizing slow database queries, choosing between EF Core and Dapper, or avoiding common performance pitfalls. /database-performance by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/database-performance)
- [

  **/dotnet-accessibility**79

  Building accessible .NET UI. SemanticProperties, ARIA, AutomationPeer, testing tools per platform. /dotnet-accessibility by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-accessibility)
- [

  **/dotnet-add-analyzers**79

  Adding analyzer packages to a project. Nullable, trimming, AOT compat analyzers, severity config. /dotnet-add-analyzers by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-add-analyzers)
- [

  **/dotnet-add-ci**79

  Adding CI/CD to a .NET project. GitHub Actions vs Azure DevOps detection, workflow templates. /dotnet-add-ci by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-add-ci)
- [

  **/dotnet-add-testing**79

  Adding test infrastructure to a .NET project. Scaffolds xUnit project, coverlet, layout. /dotnet-add-testing by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-add-testing)
- [

  **/dotnet-ado-build-test**79

  Configuring .NET build/test in Azure DevOps. DotNetCoreCLI task, Artifacts, test results. /dotnet-ado-build-test by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-ado-build-test)
- [

  **/dotnet-ado-patterns**79

  Designing composable Azure DevOps YAML pipelines. Templates, variable groups, multi-stage, triggers. /dotnet-ado-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-ado-patterns)
- [

  **/dotnet-ado-publish**79

  Publishing .NET artifacts from Azure DevOps. NuGet push, containers to ACR, pipeline artifacts. /dotnet-ado-publish by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-ado-publish)
- [

  **/dotnet-ado-unique**79

  Using ADO-exclusive features. Environments, approvals, service connections, classic releases. /dotnet-ado-unique by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-ado-unique)
- [

  **/dotnet-advisor**79

  Working with .NET, C#, ASP.NET Core, or related frameworks. Routes to specialist skills. /dotnet-advisor by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-advisor)
- [

  **/dotnet-agent-gotchas**79

  Generating or modifying .NET code. Common agent mistakes: async, NuGet, deprecated APIs, DI. /dotnet-agent-gotchas by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-agent-gotchas)
- [

  **/dotnet-aot-architecture**79

  Designing AOT-first apps. Source gen over reflection, AOT-safe DI, serialization, factories. /dotnet-aot-architecture by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-aot-architecture)
- [

  **/dotnet-aot-wasm**79

  AOT-compiling for WebAssembly. Blazor/Uno WASM AOT, size vs speed, lazy loading, Brotli. /dotnet-aot-wasm by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-aot-wasm)
- [

  **/dotnet-api-docs**79

  Generating API documentation. DocFX setup, OpenAPI-as-docs, doc-code sync, versioned docs. /dotnet-api-docs by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-api-docs)
- [

  **/dotnet-api-security**79

  Implementing API auth. Identity, OAuth/OIDC, JWT bearer, passkeys (WebAuthn), CORS, rate limiting. /dotnet-api-security by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-api-security)
- [

  **/dotnet-api-surface-validation**79

  Detecting API changes in CI. PublicApiAnalyzers, Verify snapshots, breaking change enforcement. /dotnet-api-surface-validation by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-api-surface-validation)
- [

  **/dotnet-api-versioning**79

  Versioning HTTP APIs. Asp.Versioning.Http/Mvc, URL segment, header, query string, sunset. /dotnet-api-versioning by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-api-versioning)
- [

  **/dotnet-architecture-patterns**79

  Organizing APIs at scale. Vertical slices, request pipelines, caching, error handling, idempotency. /dotnet-architecture-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-architecture-patterns)
- [

  **/dotnet-artifacts-output**79

  Using artifacts output layout. UseArtifactsOutput, ArtifactsPath, impact on CI and Docker. /dotnet-artifacts-output by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-artifacts-output)
- [

  **/dotnet-aspire-patterns**79

  Using .NET Aspire. AppHost orchestration, service discovery, components, dashboard, health checks. /dotnet-aspire-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-aspire-patterns)
- [

  **/dotnet-benchmarkdotnet**79

  Writing benchmarks. BenchmarkDotNet setup, memory diagnosers, baselines, result analysis. /dotnet-benchmarkdotnet by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-benchmarkdotnet)
- [

  **/dotnet-blazor-auth**79

  Adding auth to Blazor. AuthorizeView, CascadingAuthenticationState, Identity UI, per-model flows. /dotnet-blazor-auth by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-blazor-auth)
- [

  **/dotnet-blazor-components**79

  Building Blazor components. Lifecycle, state management, JS interop, EditForm validation, QuickGrid. /dotnet-blazor-components by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-blazor-components)
- [

  **/dotnet-blazor-patterns**79

  Building Blazor apps. Hosting models, render modes, routing, streaming rendering, prerender. /dotnet-blazor-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-blazor-patterns)
- [

  **/dotnet-blazor-testing**79

  Testing Blazor components. bUnit rendering, events, cascading params, JS interop mocking. /dotnet-blazor-testing by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-blazor-testing)
- [

  **/dotnet-build-analysis**79

  Interpreting MSBuild output, NuGet errors, or analyzer warnings. Error codes, CI drift fixes. /dotnet-build-analysis by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-build-analysis)
- [

  **/dotnet-build-optimization**79

  Diagnosing slow builds or incremental failures. Binary logs, parallel builds, restore. /dotnet-build-optimization by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-build-optimization)
- [

  **/dotnet-channels**79

  Using producer/consumer queues. Channel\<T>, bounded/unbounded, backpressure, drain patterns /dotnet-channels by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-channels)
- [

  **/dotnet-ci-benchmarking**79

  Gating CI on perf regressions. Automated threshold alerts, baseline tracking, trend reports. /dotnet-ci-benchmarking by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-ci-benchmarking)
- [

  **/dotnet-cli-architecture**79

  Structuring CLI app layers. Command/handler/service separation, clig.dev principles, exit codes. /dotnet-cli-architecture by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-cli-architecture)
- [

  **/dotnet-cli-distribution**79

  Choosing CLI output format. AOT vs framework-dependent, RID matrix, single-file, dotnet tool. /dotnet-cli-distribution by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-cli-distribution)
- [

  **/dotnet-cli-packaging**79

  Publishing to package managers. Homebrew, apt/deb, winget, Scoop, Chocolatey manifests. /dotnet-cli-packaging by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-cli-packaging)
- [

  **/dotnet-cli-release-pipeline**79

  Releasing CLI tools. GitHub Actions build matrix, artifact staging, Releases, checksums. /dotnet-cli-release-pipeline by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-cli-release-pipeline)
- [

  **/dotnet-container-deployment**79

  Deploying .NET containers. Kubernetes probes, Docker Compose for local dev, CI/CD integration. /dotnet-container-deployment by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-container-deployment)
- [

  **/dotnet-containers**79

  Containerizing .NET apps. Multi-stage Dockerfiles, SDK container publish (.NET 8+), rootless. /dotnet-containers by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-containers)
- [

  **/dotnet-cryptography**79

  Choosing crypto algorithms, hashing, encryption, or key derivation. AES-GCM, RSA, ECDSA, PQC. /dotnet-cryptography by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-cryptography)
- [

  **/dotnet-csharp-async-patterns**79

  Writing async/await code. Task patterns, ConfigureAwait, cancellation, and common agent pitfalls. /dotnet-csharp-async-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csharp-async-patterns)
- [

  **/dotnet-csharp-code-smells**79

  Reviewing C# for logic issues. Anti-patterns, common pitfalls, async misuse, DI mistakes. /dotnet-csharp-code-smells by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csharp-code-smells)
- [

  **/dotnet-csharp-configuration**79

  Using Options pattern, user secrets, or feature flags. IOptions\<T> and FeatureManagement. /dotnet-csharp-configuration by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csharp-configuration)
- [

  **/dotnet-csharp-dependency-injection**79

  Registering or resolving services with MS DI. Keyed services, scopes, decoration, hosted services. /dotnet-csharp-dependency-injection by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csharp-dependency-injection)
- [

  **/dotnet-csharp-modern-patterns**79

  Using records, pattern matching, primary constructors, collection expressions. C# 12-15 by TFM. /dotnet-csharp-modern-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csharp-modern-patterns)
- [

  **/dotnet-csharp-nullable-reference-types**79

  Enabling nullable reference types. Annotation strategies, attributes, common agent mistakes. /dotnet-csharp-nullable-reference-types by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csharp-nullable-reference-types)
- [

  **/dotnet-csharp-source-generators**79

  Creating source generators. IIncrementalGenerator, GeneratedRegex, LoggerMessage, STJ source-gen. /dotnet-csharp-source-generators by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csharp-source-generators)
- [

  **/dotnet-csproj-reading**79

  Reading or modifying .csproj files. SDK-style structure, PropertyGroup/ItemGroup, CPM, props. /dotnet-csproj-reading by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-csproj-reading)
- [

  **/dotnet-data-access-strategy**79

  Choosing a data access approach. EF Core vs Dapper vs ADO.NET decision matrix, performance tradeoffs. /dotnet-data-access-strategy by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-data-access-strategy)
- [

  **/dotnet-documentation-strategy**79

  Choosing documentation tooling. Starlight, Docusaurus, DocFX decision tree, migration paths. /dotnet-documentation-strategy by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-documentation-strategy)
- [

  **/dotnet-domain-modeling**79

  Modeling business domains. Aggregates, value objects, domain events, rich models, repositories. /dotnet-domain-modeling by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-domain-modeling)
- [

  **/dotnet-editorconfig**79

  Authoring .editorconfig rules. IDE/CA severity, AnalysisLevel, globalconfig, code style enforcement. /dotnet-editorconfig by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-editorconfig)
- [

  **/dotnet-efcore-architecture**79

  Designing data layer architecture. Read/write split, aggregate boundaries, N+1 governance. /dotnet-efcore-architecture by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-efcore-architecture)
- [

  **/dotnet-file-based-apps**79

  Running C# without a project file (.NET 10 SDK). Directives, CLI commands, migration. /dotnet-file-based-apps by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-file-based-apps)
- [

  **/dotnet-file-io**79

  Doing file I/O. FileStream, RandomAccess, FileSystemWatcher, MemoryMappedFile, paths. /dotnet-file-io by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-file-io)
- [

  **/dotnet-gc-memory**79

  Tuning GC and memory. GC modes, LOH/POH, Gen0/1/2, Span/Memory deep patterns, ArrayPool, profiling. /dotnet-gc-memory by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-gc-memory)
- [

  **/dotnet-gha-build-test**79

  Configuring .NET build/test in GitHub Actions. setup-dotnet, NuGet caching, test reporting. /dotnet-gha-build-test by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-gha-build-test)
- [

  **/dotnet-gha-deploy**79

  Deploying .NET from GitHub Actions. Azure Web Apps, GitHub Pages, container registries. /dotnet-gha-deploy by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-gha-deploy)
- [

  **/dotnet-gha-patterns**79

  Designing GitHub Actions workflows. Reusable workflows, composite actions, matrix builds, caching. /dotnet-gha-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-gha-patterns)
- [

  **/dotnet-gha-publish**79

  Publishing .NET artifacts from GitHub Actions. NuGet push, container images, signing, SBOM. /dotnet-gha-publish by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-gha-publish)
- [

  **/dotnet-github-docs**79

  Creating GitHub-native docs. README badges, CONTRIBUTING, issue/PR templates, repo metadata. /dotnet-github-docs by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-github-docs)
- [

  **/dotnet-github-releases**79

  Creating GitHub Releases for .NET. Release creation, assets, notes, pre-release management. /dotnet-github-releases by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-github-releases)
- [

  **/dotnet-grpc**79

  Building gRPC services. Proto definition, code-gen, ASP.NET Core host, streaming, auth. /dotnet-grpc by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-grpc)
- [

  **/dotnet-http-client**79

  Consuming HTTP APIs. IHttpClientFactory, typed/named clients, resilience, DelegatingHandlers. /dotnet-http-client by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-http-client)
- [

  **/dotnet-input-validation**79

  Validating HTTP request inputs. .NET 10 AddValidation, FluentValidation, ProblemDetails. /dotnet-input-validation by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-input-validation)
- [

  **/dotnet-integration-testing**79

  Testing with real infrastructure. WebApplicationFactory, Testcontainers, Aspire, fixtures. /dotnet-integration-testing by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-integration-testing)
- [

  **/dotnet-io-pipelines**79

  Building high-perf network I/O. PipeReader/PipeWriter, backpressure, protocol parsers, Kestrel. /dotnet-io-pipelines by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-io-pipelines)
- [

  **/dotnet-library-api-compat**79

  Maintaining library compatibility. Binary/source compat rules, type forwarders, SemVer impact. /dotnet-library-api-compat by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-library-api-compat)
- [

  **/dotnet-linq-optimization**79

  Optimizing LINQ queries. IQueryable vs IEnumerable, compiled queries, deferred exec, allocations. /dotnet-linq-optimization by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-linq-optimization)
- [

  **/dotnet-localization**79

  Localizing .NET apps. .resx resources, IStringLocalizer, source generators, pluralization, RTL. /dotnet-localization by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-localization)
- [

  **/dotnet-maui-aot**79

  Optimizing MAUI for iOS/Catalyst. Native AOT pipeline, size/startup gains, library gaps, trimming. /dotnet-maui-aot by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-maui-aot)
- [

  **/dotnet-maui-development**79

  Building .NET MAUI apps. Project structure, XAML/MVVM, platform services, current caveats. /dotnet-maui-development by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-maui-development)
- [

  **/dotnet-maui-testing**79

  Testing .NET MAUI apps. Appium device/emulator testing, XHarness, platform validation. /dotnet-maui-testing by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-maui-testing)
- [

  **/dotnet-mermaid-diagrams**79

  Creating Mermaid diagrams for .NET. Architecture, sequence, class, deployment, ER, flowcharts. /dotnet-mermaid-diagrams by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-mermaid-diagrams)
- [

  **/dotnet-messaging-patterns**79

  Building event-driven systems. Pub/sub, competing consumers, DLQ, sagas, delivery guarantees. /dotnet-messaging-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-messaging-patterns)
- [

  **/dotnet-minimal-apis**79

  Building Minimal APIs. Route groups, endpoint filters, TypedResults, OpenAPI 3.1, organization. /dotnet-minimal-apis by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-minimal-apis)
- [

  **/dotnet-modernize**79

  Analyzing .NET code for modernization. Outdated TFMs, deprecated packages, superseded patterns. /dotnet-modernize by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-modernize)
- [

  **/dotnet-msbuild-authoring**79

  Authoring MSBuild targets, props, or conditions. Custom targets, incrementality, Build patterns. /dotnet-msbuild-authoring by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-msbuild-authoring)
- [

  **/dotnet-msbuild-tasks**79

  Writing custom MSBuild tasks. ITask, ToolTask, IIncrementalTask, inline tasks, UsingTask. /dotnet-msbuild-tasks by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-msbuild-tasks)
- [

  **/dotnet-msix**79

  Packaging MSIX apps. Creation, signing, Store submission, App Installer sideload, auto-update. /dotnet-msix by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-msix)
- [

  **/dotnet-multi-targeting**79

  Targeting multiple TFMs or using newer C# on older TFMs. Polyfill strategy, API compat. /dotnet-multi-targeting by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-multi-targeting)
- [

  **/dotnet-native-aot**79

  Publishing Native AOT. PublishAot, ILLink descriptors, P/Invoke, size optimization, containers. /dotnet-native-aot by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-native-aot)
- [

  **/dotnet-native-interop**79

  Calling native libraries via P/Invoke. LibraryImport, marshalling, cross-platform resolution. /dotnet-native-interop by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-native-interop)
- [

  **/dotnet-nuget-authoring**79

  Creating NuGet packages. SDK-style csproj, source generators, multi-TFM, symbols, signing. /dotnet-nuget-authoring by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-nuget-authoring)
- [

  **/dotnet-observability**79

  Adding observability. OpenTelemetry traces/metrics/logs, health checks, custom metrics. /dotnet-observability by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-observability)
- [

  **/dotnet-openapi**79

  Generating OpenAPI docs. MS.AspNetCore.OpenApi (.NET 9+), Swashbuckle migration, NSwag. /dotnet-openapi by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-openapi)
- [

  **/dotnet-performance-patterns**79

  Optimizing .NET allocations/throughput. Span, ArrayPool, ref struct, sealed, stackalloc. /dotnet-performance-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-performance-patterns)
- [

  **/dotnet-playwright**79

  Automating browser tests in .NET. Playwright E2E, CI browser caching, trace viewer, codegen. /dotnet-playwright by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-playwright)
- [

  **/dotnet-profiling**79

  Diagnosing .NET performance issues. dotnet-counters, dotnet-trace, dotnet-dump, flame graphs. /dotnet-profiling by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-profiling)
- [

  **/dotnet-project-analysis**79

  Navigating .NET solution structure or build configuration. Analyzes .sln, .csproj, CPM. /dotnet-project-analysis by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-project-analysis)
- [

  **/dotnet-realtime-communication**79

  Building real-time features. SignalR hubs, SSE (.NET 10), JSON-RPC 2.0, gRPC streaming, scaling. /dotnet-realtime-communication by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-realtime-communication)
- [

  **/dotnet-release-management**79

  Managing .NET release lifecycle. NBGV versioning, SemVer, changelogs, pre-release, branching. /dotnet-release-management by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-release-management)
- [

  **/dotnet-resilience**79

  Adding fault tolerance. Polly v8 + MS.Extensions.Http.Resilience, retry/circuit breaker/timeout. /dotnet-resilience by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-resilience)
- [

  **/dotnet-roslyn-analyzers**79

  Authoring Roslyn analyzers. DiagnosticAnalyzer, CodeFixProvider, CodeRefactoring, multi-version. /dotnet-roslyn-analyzers by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-roslyn-analyzers)
- [

  **/dotnet-scaffold-project**79

  Creating a new .NET project. Generates solution with CPM, analyzers, editorconfig, SourceLink. /dotnet-scaffold-project by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-scaffold-project)
- [

  **/dotnet-secrets-management**79

  Handling secrets or sensitive configuration. User secrets, environment variables, rotation. /dotnet-secrets-management by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-secrets-management)
- [

  **/dotnet-security-owasp**79

  Securing .NET code or reviewing for vulnerabilities. OWASP Top 10 mitigations, pattern warnings. /dotnet-security-owasp by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-security-owasp)
- [

  **/dotnet-semantic-kernel**79

  Building AI/LLM features. Semantic Kernel setup, plugins, prompt templates, memory stores, agents. /dotnet-semantic-kernel by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-semantic-kernel)
- [

  **/dotnet-service-communication**79

  Choosing inter-service protocols. REST vs gRPC vs SignalR vs SSE decision matrix, tradeoffs. /dotnet-service-communication by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-service-communication)
- [

  **/dotnet-solid-principles**79

  Designing classes or refactoring. SOLID, DRY, SRP with C# anti-patterns, fixes, compliance. /dotnet-solid-principles by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-solid-principles)
- [

  **/dotnet-solution-navigation**79

  Orienting in a .NET solution. Entry points, .sln/.slnx files, dependency graphs, config. /dotnet-solution-navigation by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-solution-navigation)
- [

  **/dotnet-spectre-console**79

  Building rich console output. Spectre.Console: tables, trees, progress, prompts, live displays. /dotnet-spectre-console by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-spectre-console)
- [

  **/dotnet-structured-logging**79

  Designing log pipelines. Aggregation, structured queries, sampling, PII scrubbing, correlation. /dotnet-structured-logging by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-structured-logging)
- [

  **/dotnet-system-commandline**79

  Using System.CommandLine 2.0. Commands, options, SetAction, custom parsing, middleware, testing. /dotnet-system-commandline by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-system-commandline)
- [

  **/dotnet-terminal-gui**79

  Building full TUI apps. Terminal.Gui v2: views, layout (Pos/Dim), menus, dialogs, bindings, themes. /dotnet-terminal-gui by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-terminal-gui)
- [

  **/dotnet-test-quality**79

  Measuring test effectiveness. Coverlet code coverage, Stryker.NET mutation testing, flaky detection. /dotnet-test-quality by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-test-quality)
- [

  **/dotnet-testing-strategy**79

  Deciding how to test .NET code. Unit vs integration vs E2E decision tree, test doubles. /dotnet-testing-strategy by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-testing-strategy)
- [

  **/dotnet-tool-management**79

  Installing or managing .NET tools. Global, local, manifests, restore, version pinning. /dotnet-tool-management by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-tool-management)
- [

  **/dotnet-trimming**79

  Making apps/libraries trim-safe. Annotations, ILLink descriptors, IL2xxx warnings, IsTrimmable. /dotnet-trimming by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-trimming)
- [

  **/dotnet-tunit-test**79

  Guidelines for writing TUnit tests in .NET, including setup, assertions, async testing, and best practices. Use when writing unit tests with TUnit framework, setting up TUnit in a .NET project, or migrating from other test frameworks to TUnit. /dotnet-tunit-test by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-tunit-test)
- [

  **/dotnet-ui-chooser**79

  Selecting a .NET UI framework. Decision tree across Blazor, MAUI, Uno, WinUI, WPF, WinForms. /dotnet-ui-chooser by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-ui-chooser)
- [

  **/dotnet-ui-testing-core**79

  Testing UI across frameworks. Page objects, test selectors, async waits, accessibility. /dotnet-ui-testing-core by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-ui-testing-core)
- [

  **/dotnet-uno-mcp**79

  Using Uno MCP server. Tool detection, search-then-fetch workflow, init rules, fallback, citation. /dotnet-uno-mcp by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-uno-mcp)
- [

  **/dotnet-uno-platform**79

  Building Uno Platform apps. Extensions, MVUX reactive pattern, Toolkit controls, Hot Reload. /dotnet-uno-platform by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-uno-platform)
- [

  **/dotnet-uno-targets**79

  Deploying Uno Platform apps. Per-target guidance for WASM, iOS, Android, macOS, Windows, Linux. /dotnet-uno-targets by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-uno-targets)
- [

  **/dotnet-uno-testing**79

  Testing Uno Platform apps. Playwright for WASM, platform-specific patterns, runtime heads. /dotnet-uno-testing by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-uno-testing)
- [

  **/dotnet-version-detection**79

  Project has .csproj, global.json, or Directory.Build.props. Detects TFMs and SDK versions. /dotnet-version-detection by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-version-detection)
- [

  **/dotnet-version-upgrade**79

  Upgrading .NET to a newer TFM. LTS-to-LTS, staged through STS, preview, upgrade paths. /dotnet-version-upgrade by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-version-upgrade)
- [

  **/dotnet-winforms-basics**79

  Building WinForms on .NET 8+. High-DPI, dark mode (experimental), DI patterns, modernization tips. /dotnet-winforms-basics by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-winforms-basics)
- [

  **/dotnet-winui**79

  Building WinUI 3 apps. Windows App SDK setup, XAML patterns, MSIX/unpackaged deploy, UWP migration. /dotnet-winui by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-winui)
- [

  **/dotnet-wpf-migration**79

  Migrating desktop apps. WPF/WinForms to .NET 8+, WPF to WinUI or Uno, UWP to WinUI, decision matrix. /dotnet-wpf-migration by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-wpf-migration)
- [

  **/dotnet-wpf-modern**79

  Building WPF on .NET 8+. Host builder, MVVM Toolkit, Fluent theme, performance, modern C# patterns. /dotnet-wpf-modern by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-wpf-modern)
- [

  **/dotnet-xml-docs**79

  Writing XML doc comments. Tags, inheritdoc, GenerateDocumentationFile, warning suppression. /dotnet-xml-docs by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-xml-docs)
- [

  **/dotnet-xunit**79

  Writing xUnit tests. v3 Fact/Theory, fixtures, parallelism, IAsyncLifetime, v2 compatibility. /dotnet-xunit by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/dotnet-xunit)
- [

  **/efcore-patterns**79

  Entity Framework Core best practices including NoTracking by default, query splitting for navigation collections, migration management, dedicated migration services, interceptors, compiled queries, and connection resiliency. Use when setting up EF Core in a new project, optimizing query performance, managing database migrations, integrating EF Core with .NET Aspire, or debugging change tracking issues. /efcore-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/efcore-patterns)
- [

  **/exception-handling**79

  Comprehensive exception handling patterns for ASP.NET Core Razor Pages applications. Covers global exception handling, ProblemDetails API, custom error pages, exception middleware, and graceful degradation strategies. Use when implementing error handling in Razor Pages applications, configuring global exception middleware, or creating user-friendly error pages and API error responses. /exception-handling by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/exception-handling)
- [

  **/feature-flags**79

  Microsoft.FeatureManagement patterns for feature toggles, gradual rollouts, and A/B testing in ASP.NET Core Razor Pages applications. Use when implementing feature toggles in ASP.NET Core applications, setting up gradual feature rollouts, or configuring A/B testing scenarios with feature flags. /feature-flags by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/feature-flags)
- [

  **/file-handling**79

  File uploads, streaming, storage abstractions, and secure file handling patterns for ASP.NET Core Razor Pages applications. Use when implementing secure file uploads in Razor Pages, streaming large files, or creating storage abstractions for file operations. /file-handling by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/file-handling)
- [

  **/find-skills**79

  Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill. /find-skills by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/find-skills)
- [

  **/fly-io**79

  Deploy, configure, and manage applications on the Fly.io platform using flyctl CLI, fly.toml configuration, Fly Machines, Fly Volumes, private networking, secrets, health checks, autoscaling, and GitHub Actions CI/CD. Use when deploying any application to Fly.io, writing or modifying fly.toml configuration, managing Fly Machines or Volumes, configuring networking (public services, private 6PN, Flycast, custom domains, TLS), setting secrets, configuring health checks, setting up autostop/autostart or metrics-based autoscaling, deploying with GitHub Actions, managing Fly Postgres databases, or preparing an app for production on Fly.io. /fly-io by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/fly-io)
- [

  **/http-client-resilience**79

  IHttpClientFactory patterns with Polly for retries, circuit breakers, timeouts, and resilient HTTP communication. Includes best practices for HTTP client configuration and error handling. Use when configuring resilient HTTP clients in ASP.NET Core, implementing retry policies with Polly, or setting up circuit breakers for external service calls. /http-client-resilience by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/http-client-resilience)
- [

  **/local-tools**79

  Best practices for working with .NET local tools, including manifest management, tool installation, and versioning. Use when setting up dotnet-tools.json for a project, installing or updating local tools, or managing tool versions across team members. /local-tools by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/local-tools)
- [

  **/localization-globalization**79

  Multi-language support, resource files, culture formatting, and globalization patterns for ASP.NET Core Razor Pages applications. Use when implementing multi-language support in ASP.NET Core applications, managing resource files for translations, or formatting dates, numbers, and currencies for different cultures. /localization-globalization by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/localization-globalization)
- [

  **/logging-observability**79

  Production-grade logging and observability patterns for ASP.NET Core Razor Pages. Covers structured logging with Serilog, correlation IDs, health checks, request logging, OpenTelemetry integration, and diagnostic best practices. Use when setting up structured logging in ASP.NET Core applications, implementing distributed tracing with OpenTelemetry, or configuring health checks and observability. /logging-observability by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/logging-observability)
- [

  **/microsoft-extensions-configuration**79

  Configuration patterns using Microsoft.Extensions.Configuration. Covers configuration providers, binding, validation, and best practices for .NET applications. Use when setting up configuration in .NET applications, implementing configuration validation with IValidateOptions, or managing settings across different environments. /microsoft-extensions-configuration by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/microsoft-extensions-configuration)
- [

  **/microsoft-extensions-dependency-injection**79

  Dependency injection patterns and best practices using Microsoft.Extensions.DependencyInjection for .NET applications. Use when configuring DI containers in .NET, choosing between service lifetimes (Singleton, Scoped, Transient), or implementing decorator patterns and service interception. /microsoft-extensions-dependency-injection by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/microsoft-extensions-dependency-injection)
- [

  **/middleware-patterns**79

  Custom middleware patterns for ASP.NET Core applications. Covers request/response pipeline, middleware ordering, conditional middleware, IMiddleware factory pattern, IExceptionHandler (.NET 8+), and reusable middleware components. Use when creating custom middleware in ASP.NET Core applications, understanding middleware pipeline ordering, or implementing cross-cutting concerns like logging, authentication, and caching. /middleware-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/middleware-patterns)
- [

  **/mjml-email-templates**79

  Guidelines for creating responsive email templates using MJML framework with .NET Razor syntax integration. Use when building responsive email templates in .NET applications, integrating MJML with Razor views, or creating email layouts that work across email clients. /mjml-email-templates by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/mjml-email-templates)
- [

  **/package-management**79

  NuGet package management best practices including versioning strategies, central package management, and dependency resolution. Use when setting up Central Package Management (CPM), managing package versions across multiple projects, or resolving dependency conflicts in .NET solutions. /package-management by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/package-management)
- [

  **/playwright-blazor**79

  End-to-end testing patterns for Blazor applications using Playwright, including component testing and page navigation. Use when writing E2E tests for Blazor applications, testing Blazor component interactions with Playwright, or setting up Playwright testing infrastructure for Blazor apps. /playwright-blazor by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/playwright-blazor)
- [

  **/playwright-ci-caching**79

  Optimize CI/CD pipelines by caching Playwright browser binaries and dependencies to speed up test execution. Use when setting up Playwright in CI/CD pipelines, reducing build times by caching browser binaries, or configuring GitHub Actions or Azure DevOps for Playwright tests. /playwright-ci-caching by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/playwright-ci-caching)
- [

  **/project-structure**79

  Guidelines for organizing .NET projects, including solution structure, project references, folder conventions, .slnx format, centralized build properties, and central package management. Use when setting up a new .NET solution with modern best practices, configuring centralized build properties across multiple projects, implementing central package version management, or setting up SourceLink for debugging. /project-structure by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/project-structure)
- [

  **/rate-limiting**79

  Rate limiting patterns for ASP.NET Core Razor Pages applications. Covers fixed window, sliding window, token bucket algorithms, and distributed rate limiting with Redis. Use when implementing rate limiting in ASP.NET Core applications, choosing between different rate limiting algorithms, or setting up distributed rate limiting with Redis. /rate-limiting by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/rate-limiting)
- [

  **/razor-pages-patterns**79

  Best practices for building production-grade ASP.NET Core Razor Pages applications. Focuses on structure, lifecycle, binding, validation, security, and maintainability in web apps using Razor Pages as the primary UI framework. Use when building Razor Pages applications, designing PageModels and handlers, implementing model binding and validation, or securing Razor Pages with authentication and authorization. /razor-pages-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/razor-pages-patterns)
- [

  **/security-headers**79

  Security headers configuration and best practices for ASP.NET Core Razor Pages applications. Covers CSP, HSTS, X-Frame-Options, and comprehensive security middleware setup. Use when configuring security headers in ASP.NET Core applications, implementing Content Security Policy (CSP), or setting up HSTS and other security-related HTTP headers. /security-headers by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/security-headers)
- [

  **/serialization**79

  JSON and binary serialization patterns for .NET applications, including System.Text.Json source generators, Protocol Buffers, MessagePack, and AOT-compatible best practices. Use when configuring JSON serialization, choosing between formats, implementing Protocol Buffers for high-performance scenarios, or working with Native AOT. /serialization by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/serialization)
- [

  **/signalr-integration**79

  SignalR integration patterns for real-time communication in ASP.NET Core Razor Pages applications. Use when implementing real-time features in ASP.NET Core applications, setting up SignalR hubs and clients, or managing WebSocket connections and groups. /signalr-integration by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/signalr-integration)
- [

  **/skill-creator**79

  Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends OpenCode's capabilities with specialized knowledge, workflows, or tool integrations. /skill-creator by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/skill-creator)
- [

  **/skills-index-snippets**79

  Code snippets and templates for working with the skills index and marketplace functionality. Use when creating new skills, updating skill index files, or validating skill metadata and structure. /skills-index-snippets by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/skills-index-snippets)
- [

  **/slopwatch**79

  Patterns for detecting and managing code smells and technical debt in .NET applications. Run Slopwatch CLI to detect LLM reward hacking, disabled tests, suppressed warnings, empty catches, and other shortcuts. Use when identifying code smells, running quality gates in CI/CD, or validating LLM-generated code changes. /slopwatch by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/slopwatch)
- [

  **/snapshot-testing**79

  Patterns for snapshot testing in .NET applications using Verify. Covers API responses, scrubbing non-deterministic values, custom converters, HTTP response testing, email templates, and CI/CD integration. Use when implementing snapshot tests for API responses, verifying UI component renders, detecting unintended changes in serialization output, or approving public API surfaces. /snapshot-testing by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/snapshot-testing)
- [

  **/testcontainers**79

  Patterns for using Testcontainers in .NET integration tests to spin up real dependencies like databases and message queues. Use when writing integration tests that require real databases, testing with message brokers like RabbitMQ or Kafka, or isolating test dependencies with Docker containers. /testcontainers by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/testcontainers)
- [

  **/validation-patterns**79

  Comprehensive validation patterns for ASP.NET Core applications. Covers FluentValidation integration, DataAnnotations, IValidatableObject, IValidateOptions\<T>, MediatR pipeline behavior, and client-side validation. Use when implementing validation in ASP.NET Core applications, setting up FluentValidation, creating custom validators, configuring options validation, or implementing cross-field validation. /validation-patterns by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/validation-patterns)
- [

  **/verify-email-snapshots**79

  Patterns for verifying email snapshots in tests to ensure email content matches expected outputs. Use when testing email rendering in unit tests, verifying MJML template outputs, or ensuring email content consistency across code changes. /verify-email-snapshots by wshaddix](https://skilld.dev/gh/wshaddix/dotnet-skills/verify-email-snapshots)

Curated skills from @wshaddix. Checked GitHub just now