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
71%
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
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 the technology stack (C#/.NET), lists specific capabilities and tools, and provides explicit trigger guidance. The description uses proper third-person voice and covers both the 'what' and 'when' effectively. Minor note: 'Master' as the opening verb could be seen as slightly promotional, but it doesn't significantly detract from the overall quality.
| 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'). | 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). Unlikely to conflict with frontend skills, other language skills, or general coding skills due to the precise technology stack. | 3 / 3 |
Total | 12 / 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 .NET reference guide that explains many concepts Claude already knows. While the code examples are excellent and fully executable, the document suffers from being a monolithic wall of text (~600+ lines) with no progressive disclosure or external references. It reads more like a tutorial for a junior developer than a concise skill file that adds novel, actionable knowledge for Claude.
Suggestions
Reduce content by 60-70% — remove explanations of well-known patterns (DI lifetimes, async/await anti-patterns, basic EF Core) and keep only project-specific conventions or non-obvious patterns like the stale-while-revalidate cache or the Result type implementation.
Split into multiple files: a concise SKILL.md overview with references to separate files like DATA_ACCESS.md, CACHING.md, TESTING.md for detailed patterns.
Add explicit workflow sequences with validation steps, e.g., 'How to add a new API endpoint: 1. Define DTO → 2. Add validation → 3. Implement service → 4. Register DI → 5. Run tests → 6. Verify endpoint'.
Remove the DO/DON'T and Common Pitfalls sections entirely — these are standard .NET knowledge that Claude already possesses and they consume significant tokens without adding value.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~600+ lines. Explains many patterns Claude already knows well (DI lifetimes, async/await basics, EF Core configuration, Dapper usage). The DO/DON'T lists and Common Pitfalls sections restate widely known .NET best practices. Much of this is reference documentation Claude doesn't need. | 1 / 3 |
Actionability | All code examples are fully executable, concrete, and copy-paste ready. The examples cover complete implementations including service registration, repository patterns, caching, and testing with proper imports and realistic scenarios. | 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 a new API' or 'how to add a new feature' — it's more of a reference catalog. The project structure section implies a workflow but doesn't sequence it. | 2 / 3 |
Progressive Disclosure | Monolithic wall of content with no references to external files or any layered structure. Everything is inlined into a single massive document. Topics like caching patterns, testing patterns, and data access could each be separate referenced files, dramatically improving navigability. | 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
cf6059d
- 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.