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.
77
71%
Does it follow best practices?
Impact
85%
1.19xAverage score across 3 eval scenarios
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./tests/ext_conformance/artifacts/agents-wshobson/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 lists specific technologies and patterns, includes natural trigger terms developers would use, and has an explicit 'Use when' clause. The main weakness is the slightly broad scope that could overlap with other API or backend skills, and the word 'Master' at the beginning reads as slightly promotional rather than descriptive. 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 term 'Master' at the start is slightly promotional but the technology stack specificity helps differentiate it. | 2 / 3 |
Total | 11 / 12 Passed |
Implementation
50%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is highly actionable with excellent, executable code examples covering a broad range of .NET backend patterns. However, it is extremely verbose and largely teaches concepts Claude already knows well—DI lifetimes, async/await pitfalls, EF Core basics, and the Result pattern are all standard knowledge. The content would be far more effective as a concise overview pointing to detailed reference files, rather than a 600+ line monolith.
Suggestions
Reduce the body to ~100-150 lines focusing only on project-specific conventions, non-obvious patterns, and decisions (e.g., 'use Dapper for reads, EF for writes') rather than teaching standard C# patterns Claude already knows.
Move detailed code examples (Dapper multi-mapping, caching implementation, testing patterns) into the referenced bundle files (which are currently missing) and keep SKILL.md as a navigational overview.
Remove the DO/DON'T and Common Pitfalls sections entirely—these are basic C# knowledge that Claude possesses without instruction.
Add a concrete workflow 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') with validation checkpoints.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~600+ lines. Explains fundamental patterns Claude already knows well (DI lifetimes, async/await basics, EF Core configuration, Result pattern). The DO/DON'T lists and Common Pitfalls sections are basic knowledge for Claude. Much of this is a C# textbook rather than novel, project-specific guidance. | 1 / 3 |
Actionability | All code examples are fully executable, complete, and copy-paste ready. The examples cover real-world patterns with proper imports, class structures, and usage contexts. The DI registration, repository implementations, caching service, and test examples are all concrete and immediately usable. | 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 like 'first do X, validate, then do Y.' The 'When to Use This Skill' section lists scenarios but doesn't guide through a process. For a reference-style skill this is acceptable but the absence of any workflow for common tasks like setting up a new API project or adding a new feature is a gap. | 2 / 3 |
Progressive Disclosure | References four bundle files at the bottom (assets/service-template.cs, assets/repository-template.cs, references/ef-core-best-practices.md, references/dapper-patterns.md) which is good structure, but no bundle files are actually provided. The main file is a monolithic wall of code that could benefit from moving the detailed Dapper, caching, and testing sections into separate referenced files, keeping SKILL.md as a concise overview. | 2 / 3 |
Total | 8 / 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 (818 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- Dicklesworthstone/pi_agent_rust
- Commit
99da384
- 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.