csharp

Enforce C# coding standards for .NET Web APIs and xUnit tests.

Updated Jul 6, 2026
One-click install
npx skills add https://github.com/brenordv/claude-skill-set --skill csharp-brenordv
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: csharp
Source: https://github.com/brenordv/claude-skill-set/tree/main/skills/csharp
Command: npx skills add https://github.com/brenordv/claude-skill-set --skill csharp-brenordv

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill eliminates inconsistency and technical debt in C# projects by enforcing strict, opinionated standards for code structure, testing, and architecture that prioritize maintainability and reliability.

Core Features & Use Cases

  • Standardized Architecture: Enforces clean separation of concerns, dependency injection patterns, and modern C# syntax.
  • Rigorous Testing: Mandates xUnit with native assertions and AAA patterns while banning problematic libraries like Moq and FluentAssertions.
  • Use Case: When building a new Web API or refactoring a legacy service, this skill ensures the code follows modern .NET best practices, includes proper XML documentation, and maintains high test coverage without scope creep.

Quick Start

Apply the csharp skill to guide the implementation of a new service class and its corresponding unit tests following the repository's established patterns.

Frequently Asked Questions about csharp

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure a .NET Web API to ensure maintainable service layers?

Production-quality C# development requires standardized architecture with clean separation of concerns, strict dependency injection patterns, and modern C# syntax. This prevents inconsistency and technical debt while ensuring maintainable service layers.

What is the best way to write xUnit tests for C# without scope creep?

The best way to write xUnit tests is using native assertions and the AAA pattern while banning problematic libraries like Moq and FluentAssertions. This rigorous testing mandate ensures high coverage without scope creep.

Does this C# development approach work for refactoring legacy .NET services?

Yes, this C# development approach works for refactoring legacy services by enforcing strict, opinionated standards for code structure and architecture. It ensures legacy code follows modern .NET best practices and includes proper XML documentation.

Why does this C# testing standard prohibit specific third-party libraries?

This C# testing standard prohibits specific third-party libraries like Moq and FluentAssertions to eliminate inconsistency and technical debt. It mandates xUnit with native assertions to prioritize maintainability and reliability.

What architectural patterns are required for production-grade C# development?

Production-grade C# development requires clean separation of concerns, strict dependency injection patterns, and modern C# syntax. Adhering to these hard rules ensures high reliability and maintainability across .NET Web APIs.

How do I format C# code to meet production-quality standards?

Format C# code for production-quality by adhering to strict opinionated standards for formatting, naming conventions, and architectural patterns. This enforces modern .NET best practices and proper XML documentation across all coding tasks.