architecture-patterns
Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use this skill when designing clean architecture for a new microservice, when refactoring a monolith to use bounded contexts, when implementing hexagonal or onion architecture patterns, or when debugging dependency cycles between application layers.
64
75%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/backend-development/skills/architecture-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 articulates specific architectural patterns, provides explicit trigger scenarios via a 'Use this skill when...' clause, and uses domain-specific terminology that developers would naturally use. The description is well-structured, concise, and distinctive enough to avoid conflicts with other skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Lists multiple specific concrete patterns: Clean Architecture, Hexagonal Architecture, Domain-Driven Design, and mentions specific actions like designing microservices, refactoring monoliths, implementing onion architecture, and debugging dependency cycles. | 3 / 3 |
Completeness | Clearly answers both 'what' (implement Clean Architecture, Hexagonal Architecture, DDD patterns) and 'when' with an explicit 'Use this skill when...' clause listing four specific trigger scenarios. | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords users would say: 'clean architecture', 'hexagonal architecture', 'onion architecture', 'domain-driven design', 'bounded contexts', 'microservice', 'monolith', 'dependency cycles', 'application layers'. These cover a wide range of natural terms developers use. | 3 / 3 |
Distinctiveness Conflict Risk | Targets a clear niche of backend architecture patterns with distinct terminology (hexagonal, onion, bounded contexts, dependency cycles) that is unlikely to conflict with general coding skills or frontend skills. | 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 excellent, executable code examples covering Clean Architecture, Hexagonal Architecture, and DDD patterns with a strong testing section. However, it is significantly too verbose — large portions explain well-known architectural concepts that Claude already understands, and the content would benefit from being roughly halved. The lack of an explicit implementation workflow and the monolithic structure (despite referencing a non-existent bundle file) weaken its effectiveness as a skill.
Suggestions
Remove or drastically condense the 'Core Concepts' section — Claude already knows what Clean Architecture, Hexagonal Architecture, and DDD are. Keep only the non-obvious rules and constraints (e.g., the one-sentence dependency rule).
Add an explicit step-by-step implementation workflow (e.g., '1. Define domain entities → 2. Define ports → 3. Implement use cases → 4. Build adapters → 5. Wire DI → 6. Verify with in-memory tests') with validation checkpoints.
Split the detailed code implementations into separate bundle files (e.g., references/clean-arch-example.py, references/hexagonal-example.py, references/ddd-example.py) and keep only the directory structure and key patterns in the main SKILL.md.
Remove the 'When to Use This Skill' and 'Benefits' lists — these are already covered by the skill description metadata and add no actionable guidance.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is extremely verbose at ~400+ lines, explaining concepts Claude already knows well (Clean Architecture layers, DDD strategic/tactical patterns, hexagonal architecture benefits). Sections like 'Core Concepts' are textbook summaries that add no novel information for Claude. The 'When to Use This Skill' and 'Benefits' lists are padding. | 1 / 3 |
Actionability | The code examples are fully executable Python with complete implementations across all layers — entities, interfaces, use cases, adapters, controllers, and tests. The directory structure, import rules, and in-memory test adapter are all copy-paste ready. | 3 / 3 |
Workflow Clarity | The troubleshooting section provides clear diagnostic steps for common problems, and the testing section shows a validation approach. However, there is no explicit step-by-step workflow for actually implementing the architecture (e.g., 'start with domain entities, then define ports, then implement adapters, then wire DI'). The skill reads more like a reference than a guided process. | 2 / 3 |
Progressive Disclosure | There is a reference to 'references/advanced-patterns.md' for advanced content, but no bundle file exists to support it. The main file itself is monolithic — the full implementation code for Clean Architecture, Hexagonal, DDD, and testing could be split into separate reference files with the SKILL.md serving as a concise overview with pointers. | 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
- wshobson/agents
- Commit
112197c
- 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.