architecture-patterns
Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when architecting complex backend systems or refactoring existing applications for better maintainability.
74
59%
Does it follow best practices?
Impact
100%
1.14xAverage score across 3 eval scenarios
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/architecture-patterns/skills/architecture-patterns/SKILL.mdQuality
Discovery
67%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 description has good structure with an explicit 'Use when' clause and names specific architecture patterns, earning strong marks for completeness. However, it lacks concrete action verbs describing what the skill actually produces and misses common trigger term variations that users might naturally use when seeking architecture guidance.
Suggestions
Add more specific concrete actions like 'define bounded contexts', 'create layer boundaries', 'structure dependency injection', 'separate domain from infrastructure'
Include common trigger term variations: 'DDD', 'ports and adapters', 'onion architecture', 'layered architecture', 'separation of concerns', 'dependency inversion'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (backend architecture) and lists specific patterns (Clean Architecture, Hexagonal Architecture, DDD), but doesn't describe concrete actions beyond 'implement' and 'refactoring' - lacks specific deliverables like 'create layer boundaries', 'define domain models', or 'structure dependency injection'. | 2 / 3 |
Completeness | Clearly answers both what (implement proven backend architecture patterns including specific named patterns) and when (architecting complex backend systems or refactoring existing applications for better maintainability) with an explicit 'Use when' clause. | 3 / 3 |
Trigger Term Quality | Includes some relevant keywords like 'Clean Architecture', 'Hexagonal Architecture', 'Domain-Driven Design', 'backend systems', and 'refactoring', but misses common variations users might say like 'ports and adapters', 'onion architecture', 'DDD', 'layered architecture', 'separation of concerns', or 'dependency inversion'. | 2 / 3 |
Distinctiveness Conflict Risk | Reasonably specific to backend architecture patterns, but could overlap with general code refactoring skills, software design skills, or backend development skills. The architecture pattern names help distinguish it, but 'refactoring existing applications' is quite broad. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
52%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill provides solid, executable code examples for architecture patterns but suffers from explaining concepts Claude already knows and lacks workflow guidance for actually implementing these patterns. It reads more like a reference document than actionable instructions for architecting or refactoring systems.
Suggestions
Add a clear workflow section with numbered steps for common tasks like 'Refactoring to Clean Architecture' or 'Setting up a new project with Hexagonal Architecture', including validation checkpoints
Remove or drastically reduce the 'Core Concepts' and 'When to Use This Skill' sections - Claude knows what these patterns are; focus on project-specific implementation details
Split detailed code examples into separate reference files (e.g., CLEAN_ARCHITECTURE.md, HEXAGONAL.md, DDD.md) and keep SKILL.md as a concise overview with navigation
Add validation steps: how to verify the architecture is correctly implemented (e.g., dependency direction checks, test isolation verification)
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary explanatory content (e.g., 'When to Use This Skill' section with 7 bullet points, 'Core Concepts' section explaining what Clean Architecture/Hexagonal/DDD are). Claude already knows these architectural patterns; the skill should focus on project-specific conventions or executable patterns. | 2 / 3 |
Actionability | Provides fully executable Python code examples with complete implementations including entities, repositories, use cases, and adapters. Code is copy-paste ready with proper imports and realistic implementations. | 3 / 3 |
Workflow Clarity | No clear workflow or sequence for implementing these patterns. The skill presents concepts and code examples but lacks step-by-step guidance on how to actually architect a system, refactor existing code, or validate that the architecture is correctly implemented. | 1 / 3 |
Progressive Disclosure | Content is reasonably organized with clear sections, but it's a monolithic document with no references to external files for detailed patterns. The 200+ lines could benefit from splitting detailed implementations into separate reference files. | 2 / 3 |
Total | 8 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- secondsky/claude-skills
- Commit
90d6bd7
- 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.