architecture-patterns
Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems.
52
Quality
41%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/architecture-patterns/SKILL.mdQuality
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 a clear technical domain and names specific architecture patterns, which provides moderate specificity. However, it lacks explicit trigger guidance ('Use when...'), relies on outcome-focused language rather than concrete actions, and could benefit from more natural keyword variations to improve discoverability.
Suggestions
Add a 'Use when...' clause with explicit triggers like 'Use when structuring a new backend project, refactoring to clean architecture, implementing DDD patterns, or designing service boundaries'
Replace outcome language ('maintainable, testable, scalable') with concrete actions like 'structure code into layers, define bounded contexts, implement repository patterns, separate domain from infrastructure'
Include common keyword variations: 'ports and adapters', 'onion architecture', 'DDD', 'layered architecture', 'dependency inversion'
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (backend architecture) and lists specific patterns (Clean Architecture, Hexagonal Architecture, DDD), but describes outcomes ('maintainable, testable, scalable') rather than concrete actions like 'structure code layers' or 'define bounded contexts'. | 2 / 3 |
Completeness | Describes what the skill covers (architecture patterns) but completely lacks a 'Use when...' clause or any explicit trigger guidance for when Claude should select this skill. Missing the 'when' component caps this at 1. | 1 / 3 |
Trigger Term Quality | Includes relevant technical terms like 'Clean Architecture', 'Hexagonal Architecture', 'Domain-Driven Design', and 'backend' that users might search for, but misses common variations like 'ports and adapters', 'onion architecture', 'DDD', or 'layered architecture'. | 2 / 3 |
Distinctiveness Conflict Risk | The specific architecture pattern names provide some distinctiveness, but 'backend architecture' is broad and could overlap with general coding skills, system design skills, or other architecture-related skills. | 2 / 3 |
Total | 7 / 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.
This skill is well-structured and concise but lacks actionable content. It reads more like a table of contents or index pointing to external resources rather than a skill that provides immediate, executable guidance. The instructions are too abstract to be useful without the referenced playbook.
Suggestions
Add at least one concrete code example showing a Clean Architecture or Hexagonal Architecture folder structure with sample interface definitions
Include a minimal executable example demonstrating dependency inversion or port/adapter pattern implementation
Add specific validation checkpoints to the workflow, such as 'Verify no domain layer imports from infrastructure' or 'Run dependency analysis tool'
Provide a condensed quick-start section with actionable patterns before deferring to the external playbook
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is lean and efficient, avoiding unnecessary explanations of concepts Claude already knows. Each section serves a clear purpose without padding or verbose descriptions of what architecture patterns are. | 3 / 3 |
Actionability | The skill provides only abstract, high-level guidance with no concrete code examples, specific commands, or executable patterns. Instructions like 'Define module boundaries' and 'Select an architecture pattern' are vague and lack the specificity needed for immediate action. | 1 / 3 |
Workflow Clarity | Steps are listed in sequence (1-5), but they lack validation checkpoints and concrete verification steps. The instruction to 'refer to implementation-playbook.md' defers the actual workflow details, and there are no feedback loops for error recovery. | 2 / 3 |
Progressive Disclosure | The skill appropriately references an external resource (implementation-playbook.md) for detailed content, but the main skill body is too thin - it's essentially just a pointer to another file without providing enough standalone value or a meaningful quick-start section. | 2 / 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 | |
- Repository
- sickn33/antigravity-awesome-skills
- Commit
9c177eb
- 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.