Dotnet Skills

Implementing API auth. Identity, OAuth/OIDC, JWT bearer, passkeys (WebAuthn), CORS, rate limiting.

Choosing crypto algorithms, hashing, encryption, or key derivation. AES-GCM, RSA, ECDSA, PQC.

Authoring .editorconfig rules. IDE/CA severity, AnalysisLevel, globalconfig, code style enforcement.

Designing GitHub Actions workflows. Reusable workflows, composite actions, matrix builds, caching.

Building high-perf network I/O. PipeReader/PipeWriter, backpressure, protocol parsers, Kestrel.

Localizing .NET apps. .resx resources, IStringLocalizer, source generators, pluralization, RTL.

Testing .NET MAUI apps. Appium device/emulator testing, XHarness, platform validation.

Building Minimal APIs. Route groups, endpoint filters, TypedResults, OpenAPI 3.1, organization.

Building full TUI apps. Terminal.Gui v2: views, layout (Pos/Dim), menus, dialogs, bindings, themes.

Measuring test effectiveness. Coverlet code coverage, Stryker.NET mutation testing, flaky detection.

Building Uno Platform apps. Extensions, MVUX reactive pattern, Toolkit controls, Hot Reload.

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.

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.

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.

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.

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.

Building accessible .NET UI. SemanticProperties, ARIA, AutomationPeer, testing tools per platform.

Adding analyzer packages to a project. Nullable, trimming, AOT compat analyzers, severity config.

Generating or modifying .NET code. Common agent mistakes: async, NuGet, deprecated APIs, DI.

Publishing to package managers. Homebrew, apt/deb, winget, Scoop, Chocolatey manifests.

Writing custom MSBuild tasks. ITask, ToolTask, IIncrementalTask, inline tasks, UsingTask.

Adding observability. OpenTelemetry traces/metrics/logs, health checks, custom metrics.

Migrating desktop apps. WPF/WinForms to .NET 8+, WPF to WinUI or Uno, UWP to WinUI, decision matrix.

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.

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.

Configuring .NET build/test in Azure DevOps. DotNetCoreCLI task, Artifacts, test results.

Versioning HTTP APIs. Asp.Versioning.Http/Mvc, URL segment, header, query string, sunset.

Testing Blazor components. bUnit rendering, events, cascading params, JS interop mocking.

Interpreting MSBuild output, NuGet errors, or analyzer warnings. Error codes, CI drift fixes.

Reading or modifying .csproj files. SDK-style structure, PropertyGroup/ItemGroup, CPM, props.

Configuring .NET build/test in GitHub Actions. setup-dotnet, NuGet caching, test reporting.

Calling native libraries via P/Invoke. LibraryImport, marshalling, cross-platform resolution.

Securing .NET code or reviewing for vulnerabilities. OWASP Top 10 mitigations, pattern warnings.

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.

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.

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.

Using .NET Aspire. AppHost orchestration, service discovery, components, dashboard, health checks.

Writing benchmarks. BenchmarkDotNet setup, memory diagnosers, baselines, result analysis.

Building Blazor apps. Hosting models, render modes, routing, streaming rendering, prerender.

Gating CI on perf regressions. Automated threshold alerts, baseline tracking, trend reports.

Modeling business domains. Aggregates, value objects, domain events, rich models, repositories.

Running C# without a project file (.NET 10 SDK). Directives, CLI commands, migration.

Creating GitHub Releases for .NET. Release creation, assets, notes, pre-release management.

Targeting multiple TFMs or using newer C# on older TFMs. Polyfill strategy, API compat.

Creating NuGet packages. SDK-style csproj, source generators, multi-TFM, symbols, signing.

Building AI/LLM features. Semantic Kernel setup, plugins, prompt templates, memory stores, agents.

Building rich console output. Spectre.Console: tables, trees, progress, prompts, live displays.

Installing or managing .NET tools. Global, local, manifests, restore, version pinning.

Testing UI across frameworks. Page objects, test selectors, async waits, accessibility.

Upgrading .NET to a newer TFM. LTS-to-LTS, staged through STS, preview, upgrade paths.

Building WinForms on .NET 8+. High-DPI, dark mode (experimental), DI patterns, modernization tips.

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.

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.

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.

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.

Designing AOT-first apps. Source gen over reflection, AOT-safe DI, serialization, factories.

Using artifacts output layout. UseArtifactsOutput, ArtifactsPath, impact on CI and Docker.

Structuring CLI app layers. Command/handler/service separation, clig.dev principles, exit codes.

Choosing CLI output format. AOT vs framework-dependent, RID matrix, single-file, dotnet tool.

Validating HTTP request inputs. .NET 10 AddValidation, FluentValidation, ProblemDetails.