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
75%
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
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
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 wide range of .NET patterns. However, it is far too verbose for a SKILL.md — it reads like a comprehensive tutorial rather than a concise skill file, explaining many concepts Claude already knows (DI lifetimes, async/await anti-patterns, basic EF Core usage). The content would benefit enormously from aggressive trimming of the main file and pushing detailed patterns into referenced sub-documents.
Suggestions
Reduce the main SKILL.md to ~100-150 lines covering project structure conventions and key project-specific decisions, moving detailed pattern implementations (EF Core, Dapper, caching, testing) into separate referenced files like references/ef-core-best-practices.md
Remove explanations of concepts Claude already knows well — DI lifetime definitions (scoped/singleton/transient), basic async/await anti-patterns, and general best practices like 'use CancellationToken' and 'don't block on async'
Add a clear workflow section with sequenced steps for common tasks (e.g., 'Adding a new API endpoint: 1. Define DTO → 2. Add validation → 3. Implement service → 4. Register DI → 5. Add endpoint → 6. Write tests') with validation checkpoints
Convert the DO/DON'T and Common Pitfalls sections to a brief checklist or remove them entirely, as they contain general .NET knowledge rather than project-specific guidance
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | This is extremely verbose at ~600+ lines. It explains many 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 largely general knowledge. Much of this could be reduced to project-specific conventions and references to detailed files. | 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 clearly marked. | 3 / 3 |
Workflow Clarity | The skill presents patterns and code examples but lacks clear multi-step workflows with validation checkpoints. There's no sequenced process for building an API or setting up a project — it's a reference catalog of patterns rather than a guided workflow. For a skill covering destructive operations like database migrations or cache invalidation, explicit validation steps are missing. | 2 / 3 |
Progressive Disclosure | The skill references external files at the bottom (assets/service-template.cs, references/ef-core-best-practices.md) which is good, but the main body is a monolithic wall of code that should have much more content pushed into those reference files. The inline content for EF Core, Dapper, caching, and testing could each be separate referenced documents, with only brief examples in the main skill. | 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
47823e3
- 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.