tdg-personal/dotnet-patterns
Idiomatic C# and .NET patterns, conventions, dependency injection, async/await, and best practices for building robust, maintainable .NET applications.
55
55%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
32%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description identifies its domain (C#/.NET) and lists some relevant technical concepts, but reads more like a topic summary than an actionable skill description. It lacks concrete actions (verbs describing what it does), has no 'Use when...' clause to guide skill selection, and uses generic quality terms ('robust, maintainable') that add little discriminative value.
Suggestions
Add an explicit 'Use when...' clause, e.g., 'Use when the user is writing C# code, building .NET applications, or asking about .NET patterns like dependency injection, async/await, or LINQ.'
Replace abstract nouns with concrete actions, e.g., 'Configures dependency injection containers, implements async/await patterns, structures .NET solutions following clean architecture, writes idiomatic C# code.'
Include additional natural trigger terms users might say, such as 'ASP.NET', 'Entity Framework', 'LINQ', '.cs files', 'dotnet CLI', 'NuGet packages'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (C#/.NET) and mentions several concepts (dependency injection, async/await, patterns, conventions), but these are more like topic areas than concrete actions. It doesn't list specific actions like 'configure DI containers', 'implement repository pattern', or 'write async controller methods'. | 2 / 3 |
Completeness | Describes what the skill covers (C#/.NET patterns and practices) but completely lacks any 'Use when...' clause or explicit trigger guidance. Per the rubric, a missing 'Use when...' clause should cap completeness at 2, and since the 'what' is also somewhat vague (no concrete actions), this falls to 1. | 1 / 3 |
Trigger Term Quality | Includes relevant keywords like 'C#', '.NET', 'dependency injection', 'async/await' that users might naturally mention. However, it misses common variations like 'ASP.NET', 'Entity Framework', 'LINQ', 'NuGet', '.cs files', or 'dotnet' that users would commonly say. | 2 / 3 |
Distinctiveness Conflict Risk | The C#/.NET focus provides some distinctiveness from other language-specific skills, but 'patterns, conventions, and best practices' is broad enough to overlap with general coding skills or architecture skills. Terms like 'robust, maintainable applications' are generic and could conflict with any language-specific skill. | 2 / 3 |
Total | 7 / 12 Passed |
Implementation
57%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides high-quality, actionable C# code examples covering important .NET patterns, and the anti-patterns table is a strong addition. However, it suffers from being overly long and monolithic—many of these patterns are well-known to Claude and could be condensed or split into referenced files. The skill would benefit from a concise overview with progressive disclosure to separate reference files for detailed patterns.
Suggestions
Split detailed pattern implementations (Repository, Middleware, Minimal API, Options Pattern) into separate referenced files and keep SKILL.md as a concise overview with links
Remove or significantly condense explanations of patterns Claude already knows well (e.g., DI basics, async/await fundamentals) and focus on project-specific conventions or non-obvious gotchas
Add a brief decision guide or flowchart for when to apply which pattern (e.g., 'Use Result pattern for expected failures, exceptions for unexpected ones') to improve workflow clarity
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is mostly efficient with good code examples, but it's quite long (~200+ lines) and covers many patterns that are well-known to Claude (DI, async/await, repository pattern, middleware). Some sections like 'Explicit Over Implicit' explain concepts Claude already knows well. The anti-patterns table is efficient, but overall the skill could be significantly tightened. | 2 / 3 |
Actionability | Every pattern includes fully executable, copy-paste-ready C# code with good/bad comparisons. The examples are concrete, complete, and cover registration, usage, and implementation details. The anti-patterns table provides specific fixes for each issue. | 3 / 3 |
Workflow Clarity | This is primarily a patterns/conventions skill rather than a multi-step workflow skill, so explicit validation checkpoints are less critical. However, the 'When to Activate' section lists triggers but doesn't sequence how to apply these patterns when refactoring or designing. For a patterns skill, the individual sections are clear but there's no guidance on prioritization or decision-making between patterns. | 2 / 3 |
Progressive Disclosure | The entire skill is a monolithic wall of content with no references to external files for detailed patterns. At ~200+ lines, sections like Repository Pattern, Middleware, Minimal API, and Options Pattern could each be separate reference files linked from a concise overview. Everything is inline with no navigation structure beyond headers. | 1 / 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 |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
Reviewed
Table of Contents