OpenClaw Skills for C# and .NET Developers

The .NET ecosystem is broad. ASP.NET Core for web APIs, Entity Framework for data access, Blazor for interactive UIs, xUnit for testing, and Azure for deployment — each layer has its own conventions, patterns, and pitfalls. AI agents handle general C# syntax well enough, but the framework-specific details are where they fall short.

OpenClaw skills give your agent the specialized knowledge it needs to produce production-quality .NET code. Instead of getting a generic DbContext that misses migration best practices, or an ASP.NET controller that ignores minimal API conventions, your agent generates code that follows current .NET patterns.

This guide covers the best .NET skills in the OpenClaw Bazaar skills directory and how to combine them for different project types.

ASP.NET Core Skills

ASP.NET Core has evolved significantly. Minimal APIs, endpoint filters, output caching, and the shift away from traditional controller-based routing have changed how modern .NET web applications are structured.

aspnet-core-minimal-api (12,700 installs)

This is the most installed .NET skill on the Bazaar. It teaches your agent to build APIs using the minimal API approach introduced in .NET 6 and refined through .NET 8 and 9. The skill covers route groups with MapGroup, endpoint filters for cross-cutting concerns, typed results with TypedResults, and request validation with endpoint filters.

Without this skill, agents tend to generate traditional controller-based code with [ApiController] attributes and action methods. That still works, but it is not the direction Microsoft is pushing. If your project uses minimal APIs — or if you want to start a new project with them — this skill keeps your agent aligned with the modern approach.

aspnet-middleware-pipeline (5,400 installs)

Understanding the ASP.NET Core middleware pipeline is critical for building robust web applications. This skill teaches your agent how to structure middleware ordering correctly — authentication before authorization, CORS before routing, exception handling at the top of the pipeline. It also covers custom middleware creation, including how to inject services via constructor injection and when to use IMiddleware versus convention-based middleware.

The skill is especially useful for agents working on middleware that interacts with the request and response body, where buffering and stream position management cause subtle bugs that are hard to diagnose.

aspnet-auth-patterns (7,100 installs)

Authentication and authorization in ASP.NET Core involve multiple moving parts: JWT bearer tokens, cookie authentication, policy-based authorization, claims transformation, and integration with identity providers. This skill teaches your agent to configure these correctly, including the common pattern of combining JWT tokens for API endpoints with cookie auth for server-rendered pages.

It also covers the newer IAuthorizationRequirementHandler pattern for custom authorization logic and the [Authorize] attribute with policy names for endpoint-level access control.

Entity Framework Core Skills

Entity Framework Core is the standard ORM for .NET, and it has enough configuration options and behavioral nuances to fill a book. Agents need specific guidance to avoid generating inefficient queries and misconfigured migrations.

ef-core-expert (10,300 installs)

This comprehensive skill covers Entity Framework Core from initial setup through advanced query optimization. It teaches your agent to configure DbContext classes with proper connection string management, define entity configurations using the Fluent API in separate IEntityTypeConfiguration<T> classes, and write efficient LINQ queries that translate cleanly to SQL.

The query optimization guidance is where this skill shines. It teaches your agent to avoid the N+1 query problem with Include and ThenInclude, use AsNoTracking for read-only queries, project with Select to fetch only needed columns, and batch operations with ExecuteUpdate and ExecuteDelete introduced in EF Core 7.

ef-core-migrations (4,600 installs)

Migrations deserve their own skill because they are a frequent source of production issues. This skill teaches your agent to generate migrations with dotnet ef migrations add, review the generated SQL with dotnet ef migrations script, handle data migrations that go beyond schema changes, and set up idempotent migration scripts for CI/CD pipelines.

It also covers the tricky scenarios: renaming columns without losing data, splitting tables, and handling migrations across multiple DbContext instances in the same project.

Blazor Skills

Blazor lets you build interactive web UIs with C# instead of JavaScript. Whether you use Blazor Server, Blazor WebAssembly, or the newer Blazor United model, your agent needs to understand the component lifecycle and rendering model.

blazor-components (8,200 installs)

This skill teaches your agent to build Blazor components following best practices: parameter binding with [Parameter], cascading values, event callbacks with EventCallback<T>, and component lifecycle methods (OnInitializedAsync, OnParametersSetAsync, OnAfterRenderAsync). It covers the render mode system introduced in .NET 8, including @rendermode InteractiveServer, @rendermode InteractiveWebAssembly, and @rendermode InteractiveAuto.

The skill also addresses state management patterns for Blazor, including scoped services for per-circuit state in Blazor Server, and the cascading state pattern for sharing data between components without coupling them.

blazor-forms-validation (3,900 installs)

Forms in Blazor use the EditForm component with data annotations or Fluent Validation for input validation. This skill teaches your agent to build forms with proper validation, including custom validation attributes, server-side validation that feeds back to the UI, and the newer EditForm enhancements with FormName for static SSR form handling. It pairs naturally with blazor-components for full UI coverage.

xUnit Testing Skills

Testing in .NET centers on xUnit, and good test code requires more than just knowing the [Fact] and [Theory] attributes.

xunit-dotnet-testing (9,100 installs)

This skill covers xUnit testing patterns for .NET projects comprehensively. It teaches your agent to write unit tests with [Fact] and parameterized tests with [Theory] and [InlineData], set up test fixtures with IClassFixture<T> and ICollectionFixture<T>, and use mocking frameworks like Moq and NSubstitute to isolate dependencies.

For integration testing, the skill covers WebApplicationFactory<T> for testing ASP.NET Core APIs, TestServer configuration, and how to replace services in the DI container for test scenarios. It also teaches your agent to use Respawn for database cleanup between integration tests and Testcontainers for running dependencies like SQL Server in Docker during tests.

dotnet-test-architecture (4,200 installs)

This skill focuses on test project organization rather than individual test patterns. It teaches your agent to structure test projects with clear separation between unit tests, integration tests, and end-to-end tests. It covers naming conventions, test data builders, the Arrange-Act-Assert pattern, and how to share test utilities across multiple test projects using a common test infrastructure project.

Azure Deployment Skills

Deploying .NET applications to Azure involves App Service, Azure Functions, container apps, and a growing list of managed services.

azure-dotnet-deploy (6,500 installs)

This skill teaches your agent to configure .NET applications for Azure deployment. It covers App Service deployment with web.config and startup configuration, Azure Functions with the isolated worker model, and container-based deployment with Azure Container Apps. The skill includes ARM template and Bicep file generation for infrastructure-as-code, which is where agents without Azure-specific training tend to produce the most errors.

azure-devops-pipeline (5,800 installs)

For teams using Azure DevOps for CI/CD, this skill teaches your agent to write YAML pipeline definitions that build, test, and deploy .NET applications. It covers multi-stage pipelines, environment approvals, variable groups for secret management, and the DotNetCoreCLI@2 task configuration. It also handles the common pattern of building once and deploying to multiple environments with stage-specific variable substitution.

Recommended Skill Combinations

For a typical ASP.NET Core web API project, start with aspnet-core-minimal-api, ef-core-expert, and xunit-dotnet-testing. That gives your agent solid coverage for the most common development tasks.

For full-stack Blazor projects, add blazor-components and blazor-forms-validation. For projects heading to Azure, add azure-dotnet-deploy.

Explore all .NET and C# skills in the OpenClaw Bazaar skills directory to find the right combination for your stack.

Browse the Skills Directory

Find the right skill for your workflow. The OpenClaw Bazaar skills directory has over 2,300 community-rated skills — searchable, sortable, and free to install.

Browse Skills →

Built a Skill? List It on the Bazaar

If you have built a skill that others would find useful, publish it on the Bazaar. Reach thousands of developers and get feedback from the community.

Learn how to publish →