dotnet-backend-patterns
Master C#/.NET backend development patterns for building robust APIs, MCP servers, and enterprise applications. Covers async/await, dependency injection, Entity Framework Core, Dapper, configuration, caching, and testing with xUnit. Use when developing .NET backends, reviewing C# code, or designing API architectures.
80
71%
Does it follow best practices?
Impact
85%
1.32xAverage score across 6 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/dotnet-contribution/skills/dotnet-backend-patterns/SKILL.mdQuality
Discovery
100%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a strong skill description that clearly identifies its domain (C#/.NET backend), lists specific technologies and patterns covered, and includes an explicit 'Use when' clause with natural trigger terms. The only minor concern is the use of 'Master' at the beginning which reads slightly like marketing language, but the rest of the description is concrete and well-structured.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete actions and technologies: async/await, dependency injection, Entity Framework Core, Dapper, configuration, caching, testing with xUnit, building APIs, MCP servers, and enterprise applications. | 3 / 3 |
Completeness | Clearly answers both 'what' (C#/.NET backend development patterns covering specific technologies) and 'when' with an explicit 'Use when developing .NET backends, reviewing C# code, or designing API architectures' clause. | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords users would say: 'C#', '.NET', 'backend', 'API', 'MCP servers', 'Entity Framework', 'Dapper', 'xUnit', 'dependency injection', 'async/await'. These cover a wide range of terms a developer would naturally use. | 3 / 3 |
Distinctiveness Conflict Risk | Clearly scoped to C#/.NET backend development with specific technology mentions (Entity Framework Core, Dapper, xUnit, MCP servers) that create a distinct niche unlikely to conflict with skills for other languages or frontend development. | 3 / 3 |
Total | 12 / 12 Passed |
Implementation
42%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is essentially a comprehensive .NET reference guide dumped into a single file. While the code examples are high-quality and executable, the content is far too verbose for a skill file—it explains many patterns Claude already knows (DI lifetimes, async/await anti-patterns, basic EF Core usage) and would consume significant context window space. The lack of progressive disclosure means Claude loads ~600 lines even when only needing one specific pattern.
Suggestions
Split into multiple files: keep SKILL.md as a concise overview (~50-80 lines) with links to separate files like DATA-ACCESS.md, CACHING.md, TESTING.md, and DI-PATTERNS.md
Remove explanations of concepts Claude already knows: DI lifetime definitions, why async void is bad, what ConfigureAwait does, basic DO/DON'T lists, and Common Pitfalls that are standard .NET knowledge
Add a workflow section with sequenced steps for common tasks like 'Setting up a new API project' or 'Adding a new endpoint with caching' with validation checkpoints
Reduce code examples to the minimum novel patterns—e.g., the keyed services and factory pattern are worth keeping, but basic repository CRUD and standard xUnit setup can be drastically shortened
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | At ~600+ lines, this is extremely verbose. It explains patterns Claude already knows well (DI lifetimes, async/await basics, Result pattern, EF Core configuration, Dapper usage). The DO/DON'T lists and Common Pitfalls sections are basic knowledge for Claude. Nearly every section could be cut by 50-70% without losing actionable value. | 1 / 3 |
Actionability | The code examples are fully executable, concrete, and copy-paste ready. Every pattern includes complete, working C# code with proper using statements, class definitions, and realistic scenarios including EF Core configuration, Dapper queries, caching implementations, and test examples. | 3 / 3 |
Workflow Clarity | While individual patterns are well-demonstrated, there's no clear workflow for how to compose these patterns together when building a new API or MCP server. The skill reads as a reference catalog rather than a guided process. There are no validation checkpoints or sequenced steps for common development workflows. | 2 / 3 |
Progressive Disclosure | This is a monolithic wall of code and text with no references to external files. At this length, the caching patterns, testing patterns, and data access patterns should each be in separate referenced files. Everything is inline with no navigation structure beyond section headers. | 1 / 3 |
Total | 7 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (811 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- wshobson/agents
- Commit
27a7ed9
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.