Dotnet Skills

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.

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.

Building gRPC services. Proto definition, code-gen, ASP.NET Core host, streaming, auth.

Packaging MSIX apps. Creation, signing, Store submission, App Installer sideload, auto-update.

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.

Building WinUI 3 apps. Windows App SDK setup, XAML patterns, MSIX/unpackaged deploy, UWP migration.

Writing xUnit tests. v3 Fact/Theory, fixtures, parallelism, IAsyncLifetime, v2 compatibility.

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.

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.

Adding CI/CD to a .NET project. GitHub Actions vs Azure DevOps detection, workflow templates.

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.

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.

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.

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.

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.

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.

Working with .NET, C#, ASP.NET Core, or related frameworks. Routes to specialist skills.

Doing file I/O. FileStream, RandomAccess, FileSystemWatcher, MemoryMappedFile, paths.

Generating OpenAPI docs. MS.AspNetCore.OpenApi (.NET 9+), Swashbuckle migration, NSwag.

Using Uno MCP server. Tool detection, search-then-fetch workflow, init rules, fallback, citation.

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.

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.

AOT-compiling for WebAssembly. Blazor/Uno WASM AOT, size vs speed, lazy loading, Brotli.

Generating API documentation. DocFX setup, OpenAPI-as-docs, doc-code sync, versioned docs.

Using producer/consumer queues. Channel<T>, bounded/unbounded, backpressure, drain patterns

Optimizing MAUI for iOS/Catalyst. Native AOT pipeline, size/startup gains, library gaps, trimming.

Making apps/libraries trim-safe. Annotations, ILLink descriptors, IL2xxx warnings, IsTrimmable.

Writing XML doc comments. Tags, inheritdoc, GenerateDocumentationFile, warning suppression.

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.

Tuning GC and memory. GC modes, LOH/POH, Gen0/1/2, Span/Memory deep patterns, ArrayPool, profiling.

Analyzing .NET code for modernization. Outdated TFMs, deprecated packages, superseded patterns.

Diagnosing .NET performance issues. dotnet-counters, dotnet-trace, dotnet-dump, flame graphs.

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.

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.

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.

Using ADO-exclusive features. Environments, approvals, service connections, classic releases.

Containerizing .NET apps. Multi-stage Dockerfiles, SDK container publish (.NET 8+), rootless.

Deploying .NET from GitHub Actions. Azure Web Apps, GitHub Pages, container registries.

Publishing Native AOT. PublishAot, ILLink descriptors, P/Invoke, size optimization, containers.

Automating browser tests in .NET. Playwright E2E, CI browser caching, trace viewer, codegen.

Adding fault tolerance. Polly v8 + MS.Extensions.Http.Resilience, retry/circuit breaker/timeout.

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.

Selecting a .NET UI framework. Decision tree across Blazor, MAUI, Uno, WinUI, WPF, WinForms.

Building WPF on .NET 8+. Host builder, MVVM Toolkit, Fluent theme, performance, modern C# patterns.

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.

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.

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.

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.

Adding test infrastructure to a .NET project. Scaffolds xUnit project, coverlet, layout.

Publishing .NET artifacts from Azure DevOps. NuGet push, containers to ACR, pipeline artifacts.

Adding auth to Blazor. AuthorizeView, CascadingAuthenticationState, Identity UI, per-model flows.

Publishing .NET artifacts from GitHub Actions. NuGet push, container images, signing, SBOM.

Creating GitHub-native docs. README badges, CONTRIBUTING, issue/PR templates, repo metadata.

Consuming HTTP APIs. IHttpClientFactory, typed/named clients, resilience, DelegatingHandlers.

Deploying Uno Platform apps. Per-target guidance for WASM, iOS, Android, macOS, Windows, Linux.

Testing Uno Platform apps. Playwright for WASM, platform-specific patterns, runtime heads.

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.

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.

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.

Designing composable Azure DevOps YAML pipelines. Templates, variable groups, multi-stage, triggers.