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 communicates its scope across C#/.NET backend development with specific technologies and patterns listed. It includes an explicit 'Use when' clause with relevant triggers. The main weakness is its breadth—it covers so many topics (ORMs, caching, testing, DI, APIs) that it functions as a broad .NET catch-all, which could overlap with more specialized skills in those individual areas.
| 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 ('building robust APIs, MCP servers, enterprise applications' with specific technologies) and when ('Use when developing .NET backends, reviewing C# code, or designing API architectures') with explicit trigger guidance. | 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 C#/.NET is a specific ecosystem, the description is quite broad covering APIs, enterprise applications, and many patterns. It could overlap with general API design skills, testing skills, or database/ORM skills. The 'Master' framing and breadth of topics (caching, configuration, DI, testing) make it a catch-all for .NET work rather than a tightly scoped skill. | 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.
This skill is a comprehensive but excessively verbose reference document that explains many patterns Claude already knows well. While the code examples are high-quality and executable, the sheer volume (~500+ lines) wastes context window budget on standard .NET knowledge. It would benefit enormously from aggressive trimming to project-specific conventions and splitting detailed patterns into separate reference files.
Suggestions
Reduce the main SKILL.md to a concise overview (~50-80 lines) covering only project-specific conventions and decisions (e.g., 'we use Dapper for reads, EF Core for writes'), and move detailed code examples to separate reference files like DATA-ACCESS.md, CACHING.md, TESTING.md.
Remove explanations of standard patterns Claude already knows (async/await anti-patterns, DI lifetime descriptions, basic EF Core configuration, Result pattern implementation) and replace with brief references to project-specific choices.
Add explicit workflow sequences with validation steps, e.g., 'When creating a new API endpoint: 1. Define DTO → 2. Add validation → 3. Implement service with Result<T> → 4. Write unit test → 5. Write integration test → 6. Verify with dotnet test'.
Cut the DO/DON'T and Common Pitfalls sections entirely—these are general .NET best practices Claude already knows, not project-specific guidance.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | At ~500+ lines, this is extremely verbose. It explains patterns Claude already knows well (DI lifetimes, async/await anti-patterns, Result pattern, EF Core configuration, Dapper usage, xUnit testing). The DO/DON'T lists and Common Pitfalls sections are basic knowledge for Claude. Very little here is novel or project-specific. | 1 / 3 |
Actionability | The code examples are fully executable, complete, and copy-paste ready. Every pattern includes concrete C# implementations with proper using statements, realistic class structures, and both correct and incorrect usage examples. | 3 / 3 |
Workflow Clarity | The project structure and patterns are well-organized, but there are no explicit multi-step workflows with validation checkpoints. The 'When to Use This Skill' section lists scenarios but doesn't sequence them. For a skill covering enterprise development patterns, there's no guidance on the order of operations when building a new service or migrating existing code. | 2 / 3 |
Progressive Disclosure | This is a monolithic wall of content with no references to external files. All patterns (DI, async, caching, testing, EF Core, Dapper) are inlined in a single massive document. Content should be split into separate reference files (e.g., CACHING.md, TESTING.md, DATA-ACCESS.md) with a concise overview in the main skill. | 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
70444e5
- 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.