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 overall the description is well-structured and highly functional for skill selection.
| 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.
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 far too verbose for a SKILL.md file—most of the content covers patterns Claude already knows (async/await, DI, EF Core basics) and should either be omitted or moved to referenced detail files. The lack of clear multi-step workflows and the monolithic structure significantly reduce its effectiveness as a concise, actionable skill guide.
Suggestions
Reduce the main SKILL.md to ~100 lines covering only project-specific conventions and decisions (e.g., 'Use Result<T> pattern, prefer Dapper for reads, EF Core for writes'), moving detailed code examples to referenced files like references/async-patterns.md, references/caching-patterns.md, etc.
Remove explanations of concepts Claude already knows well (async/await basics, DI lifetime descriptions, what EF Core is) and focus only on project-specific choices and non-obvious patterns.
Add explicit multi-step workflows with validation checkpoints for common tasks like 'Adding a new API endpoint' or 'Setting up a new service with DI, caching, and tests'.
Restructure as a concise overview with well-signaled one-level-deep references, e.g., '## Data Access: See [references/data-access.md] for EF Core and Dapper patterns'.
| 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, concrete, and copy-paste ready. Every pattern includes complete 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 sequential workflows for multi-step processes like setting up a new project, implementing a feature end-to-end, or migrating data access layers. There are no validation checkpoints or feedback loops for operations like database migrations or deployment. | 2 / 3 |
Progressive Disclosure | References to external files exist at the bottom (assets/service-template.cs, references/ef-core-best-practices.md), but the main file is a monolithic wall of code that should have much of its content moved to those referenced files. The EF Core, Dapper, caching, and testing sections could each be separate files with only summaries 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
6e3d68c
- 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.