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.
79
67%
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
92%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, and includes an explicit 'Use when' clause with relevant triggers. The main weakness is the slightly broad scope ('enterprise applications', 'API architectures') which could overlap with other backend skills, and the use of 'Master' as a leading verb which reads more as marketing language than a concrete action. Overall it performs well across all dimensions.
| 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 | While it targets C#/.NET specifically which is a clear niche, the broad scope covering APIs, enterprise applications, and general backend development could overlap with other backend or API-focused skills. The 'Master' framing and 'enterprise applications' are somewhat broad, though the C#/.NET specificity helps. | 2 / 3 |
Total | 11 / 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.
The skill provides high-quality, executable C# code examples covering a broad range of .NET backend patterns, which is its primary strength. However, it is severely over-scoped and verbose — it attempts to be a comprehensive .NET reference guide rather than a focused skill, covering many topics Claude already knows well. The lack of any progressive disclosure structure (no bundle files, no external references) and the absence of clear multi-step workflows significantly reduce its effectiveness as a skill document.
Suggestions
Split into focused sub-skills (e.g., separate files for caching patterns, data access, testing, DI) with SKILL.md serving as a brief overview with links to each.
Remove content Claude already knows (basic async/await rules, DI lifetime definitions, standard EF Core configuration) and focus only on project-specific conventions or non-obvious patterns.
Add explicit workflow sequences for common tasks (e.g., 'Adding a new API endpoint: 1. Create DTO → 2. Add validator → 3. Implement service → 4. Register DI → 5. Add endpoint → 6. Write tests').
Reduce the DO/DON'T and Common Pitfalls sections to only non-obvious items, or remove them entirely since they restate standard .NET guidance.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | This is extremely verbose at ~600+ lines, covering numerous topics Claude already knows well (async/await patterns, DI lifetimes, EF Core configuration, Dapper usage, xUnit testing). The DO/DON'T lists and Common Pitfalls sections restate widely-known .NET best practices. Very little here is novel information that Claude wouldn't already know. | 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, realistic class structures, and both correct and incorrect usage examples clearly marked. | 3 / 3 |
Workflow Clarity | The skill presents patterns and code examples but lacks explicit multi-step workflows with validation checkpoints. There's no clear sequence for 'how to build an API from scratch' or 'how to add caching to an existing service' — it's a reference catalog rather than a guided workflow. The 'When to Use This Skill' section lists triggers but doesn't connect them to ordered steps. | 2 / 3 |
Progressive Disclosure | This is a monolithic wall of text with no references to external files and no bundle structure. All content — project structure, DI, async, configuration, Result pattern, EF Core, Dapper, caching, testing, best practices, and pitfalls — is inlined in a single massive file. Topics like Dapper multi-mapping or stale-while-revalidate caching could easily be separate reference files. | 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
112197c
- 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.