Top 10 C# Skills for AI Coding Agents

Best for: Designing maintainable, null-safe, composable, and high-performance C# APIs

modern-csharp-coding-standards focuses on practical C# design across records and readonly record structs, nullability, pattern matching, and composition. Authored by Aaron Stannard and Petabridge, it also covers Result handling, Span/Memory, asynchronous code with cancellation, and high-performance API design.

This card serves as the single universal core standards default in the C# catalog. Use it broadly when authoring, modifying, or refactoring C# source code, while loading the other cards only for their specific testing, diagnostic, runtime, or framework workflows.

• Records and readonly record structs for clear data-oriented design
• Nullability and pattern matching for safer, expressive code
• Composition and Result handling for explicit application flow
• Span/Memory, async/cancellation, and high-performance API design

Best for: Asynchronous method authoring, cancellation plumbing, and async concurrency performance

csharp-async provides specialized guidance for the Task-based Asynchronous Pattern in C#. It teaches coding agents how to structure asynchronous methods cleanly, correctly propagate CancellationToken instances through async call stacks, and select ValueTask for high-frequency methods that frequently complete synchronously.

Load this skill conditionally when working on asynchronous workflows, concurrent pipelines, background hosted services, or I/O-bound integrations. It explicitly guards against sync-over-async hazards like .Result and .GetAwaiter().GetResult() that lead to thread pool starvation and application deadlocks.

• CancellationToken propagation and cooperative cancellation handling
• ValueTask allocation reduction on synchronous completion paths
• Deadlock prevention by avoiding sync-over-async blocking calls
• IAsyncEnumerable streaming for asynchronous data sequences

Best for: Documenting public C# APIs, NuGet package libraries, and IntelliSense annotations

csharp-docs directs agents in generating accurate XML documentation comments for C# types and public members. It structures standard documentation tags including summary, param, typeparam, returns, exception, and remarks blocks so that public interfaces are thoroughly documented for consumers.

Select this skill conditionally when building public libraries, preparing NuGet packages, writing shared API contracts, or executing codebase documentation audits. It is not required during internal logic modifications where XML doc authoring is out of scope.

• Standard XML documentation tags for classes, methods, and properties
• Explicit exception documentation with cref type references
• Generic type parameter annotations and remarks examples
• IntelliSense-friendly formatting and NuGet package doc generation

Best for: Writing maintainable xUnit unit and integration tests, parameterizing cases, and asserting behavior

csharp-testing is an xUnit-centered workflow for .NET unit and integration tests. It guides clean Arrange-Act-Assert structures, parameterized test cases, and expressive assertion chains with FluentAssertions, alongside test doubles using NSubstitute or Moq.

Activate this skill conditionally when writing tests, validating bug fixes with regression coverage, or building integration environments. It covers WebApplicationFactory, Testcontainers, and data builders while keeping tests isolated, readable, and resilient to refactoring.

• xUnit-centered unit and integration test structure
• Parameterized test theories for diverse scenario validation
• FluentAssertions for readable and expressive test verifications
• NSubstitute/Moq, WebApplicationFactory, Testcontainers, and data builders

Best for: Static source scans for known C#/.NET performance anti-patterns

analyzing-dotnet-performance is a static C#/.NET source scan from the official Microsoft .NET diagnostics repository. It checks for known performance anti-patterns across async code, allocations, strings, LINQ, regex, and I/O operations.

Use this card conditionally during source review and refactoring to find those known patterns. It is not algorithmic complexity analysis or runtime profiling, so use dotnet-trace-collect for investigation of a running process.

• Static scan for known C#/.NET performance anti-patterns
• Async and allocation pattern checks
• String, LINQ, regex, and I/O pattern checks
• Explicitly separate from algorithmic complexity analysis and runtime profiling

Best for: Diagnosing live production or staging process hangs, CPU spikes, and GC stalls across platforms

dotnet-trace-collect provides command recipes and procedures for collecting diagnostic traces from running .NET applications using the dotnet-trace CLI tool. It guides process discovery, provider configuration (such as EventPipe CPU sampling and GC events), trace duration management, and export into Speedscope or Chromium trace formats.

Select this skill conditionally when investigating active runtime issues, CPU spikes, or deadlocks in environments where diagnostic tools can be executed. Because it requires process-level access, it is a runtime operations workflow rather than a static source code authoring skill.

• dotnet-trace command synthesis for live process inspection
• EventPipe provider selection for CPU and runtime event capture
• Cross-platform trace output generation for Speedscope and PerfView
• Low-overhead collection suitable for production troubleshooting

Best for: Preparing .NET 8+ applications for Native AOT publishing, trimming, and small container images

dotnet-aot-compat assists in adapting .NET applications for Native Ahead-Of-Time (AOT) compilation and IL trimming. It guides agents in identifying and fixing IL2026 and IL3050 warnings, replacing dynamic reflection with compile-time C# source generators, and configuring System.Text.Json source generation.

Load this skill conditionally when targeting Native AOT deployments, building lightweight container images, or optimizing cold-start latency on .NET 8+. It is not required for standard JIT-compiled applications that do not enable trimming.

• Trimming and Native AOT warning diagnosis and resolution
• Source generator adoption for JSON serialization and dependency injection
• Type annotations with DynamicallyAccessedMembers and RequiresUnreferencedCode
• Publish verification and container binary footprint minimization

Best for: Calling C/C++ native libraries and operating system APIs from .NET Framework or modern .NET 7+/Native AOT

dotnet-pinvoke delivers advanced patterns for platform invocation (P/Invoke) across .NET targets. It distinguishes traditional DllImport for .NET Framework from the compile-time LibraryImport source generator for modern .NET 7+ and Native AOT scenarios, and covers custom marshaling plus safe unmanaged resource encapsulation with SafeHandle.

Use this card conditionally when integrating native C or C++ dynamic libraries, operating system APIs, or custom unmanaged drivers into a .NET solution. Pure managed C# applications do not need this interop workflow.

• DllImport for .NET Framework and LibraryImport for modern .NET 7+/Native AOT
• SafeHandle encapsulation for unmanaged resource lifetime safety
• Custom marshallers for complex native struct and string conversions
• Architecture-specific calling conventions and platform target handling

Best for: Building REST APIs, backend microservices, and web endpoints in ASP.NET Core

aspnet-core from OpenAI provides structured architecture workflows for building web applications and backend APIs in ASP.NET Core. It guides agents through Minimal API route declarations, controller design, dependency injection service lifetime registration (Transient, Scoped, Singleton), and HTTP middleware pipeline orchestration.

Choose this skill conditionally when implementing web endpoints, REST services, or backend APIs with ASP.NET Core. It provides domain-specific expertise for web servers that goes beyond general language syntax.

• Minimal APIs and controller-based routing patterns
• Dependency injection service lifetime management and configuration binding
• HTTP middleware pipeline construction and exception handling
• Entity Framework Core integration with LINQ query optimization

Best for: Exporting distributed traces and runtime metrics to OpenTelemetry collectors and monitoring backends

configuring-opentelemetry-dotnet guides the setup of standardized OpenTelemetry observability within .NET services. It covers ActivitySource tracing, Meter metrics instrumentation, built-in telemetry for ASP.NET Core and HttpClient, and OTLP exporter integration for streaming telemetry to monitoring platforms.

Load this skill conditionally when adding distributed tracing, metrics dashboards, or structured telemetry pipelines to .NET microservices. It focuses specifically on telemetry configuration rather than core business logic.

• ActivitySource and Meter setup for custom application telemetry
• Built-in instrumentation for ASP.NET Core, HttpClient, and SQL queries
• OTLP exporter configuration for OpenTelemetry collector ingestion
• Resource attribute tagging with service names and environment metadata