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.
Install with Tessl CLI
npx tessl i github:Dicklesworthstone/pi_agent_rust --skill architecture-patterns76
Does it follow best practices?
If you maintain this skill, you can automatically optimize it using the tessl CLI to improve its score:
npx tessl skill review --optimize ./path/to/skillValidation for skill structure
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 a solid structure with explicit 'what' and 'when' clauses, earning full marks for completeness. However, it lacks specificity in concrete actions (what exactly does 'implement' mean here?) and could benefit from more natural trigger terms that users commonly use when seeking architecture guidance.
Suggestions
Add more concrete actions like 'structure code into layers', 'define bounded contexts', 'create repository interfaces', 'separate domain logic from infrastructure'
Include common trigger term variations like 'DDD', 'ports and adapters', 'onion architecture', 'code organization', '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 detail on what specific tasks it performs. | 2 / 3 |
Completeness | Clearly answers both what ('Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design') and when ('Use when architecting complex backend systems or refactoring existing applications for better maintainability') with explicit trigger guidance. | 3 / 3 |
Trigger Term Quality | Includes some relevant terms like 'Clean Architecture', 'Hexagonal Architecture', 'Domain-Driven Design', 'backend systems', and 'maintainability', but misses common variations users might say like 'ports and adapters', 'onion architecture', 'layered architecture', 'DDD', or 'code organization'. | 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' and 'maintainability' are broad terms. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
72%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides excellent, executable code examples demonstrating Clean Architecture, Hexagonal Architecture, and DDD patterns. However, it's verbose with conceptual explanations Claude doesn't need, and lacks explicit workflow guidance for actually implementing these patterns in a project (e.g., 'start here, validate this, then proceed').
Suggestions
Remove or drastically condense the 'Core Concepts' section - Claude knows what Clean Architecture layers and DDD patterns are; jump straight to implementation patterns.
Add a workflow section with explicit steps: '1. Identify bounded contexts → 2. Define domain entities → 3. Create repository interfaces → 4. Implement adapters → 5. Wire up dependency injection'
Remove the 'When to Use This Skill' section - this is meta-information that doesn't help Claude execute the skill.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill contains some unnecessary explanatory content (e.g., explaining what Clean Architecture layers are, what DDD patterns mean) that Claude already knows. The 'When to Use This Skill' section and 'Core Concepts' overview add bulk before getting to actionable content. | 2 / 3 |
Actionability | Provides fully executable Python code examples with complete implementations of entities, repositories, use cases, controllers, and adapters. Code is copy-paste ready with proper imports and realistic patterns. | 3 / 3 |
Workflow Clarity | While the code examples show how components connect, there's no explicit step-by-step workflow for implementing these patterns in a project. Missing validation checkpoints for architectural decisions or refactoring processes. | 2 / 3 |
Progressive Disclosure | Clear structure with overview sections followed by detailed implementations. References to external files (references/clean-architecture-guide.md, assets/clean-architecture-template/) are well-signaled and one level deep. | 3 / 3 |
Total | 10 / 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.
- 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.