architecture-patterns
Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems.
32
27%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/antigravity-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 names specific architecture patterns which gives it some identity, but it reads more like a course title or marketing tagline than a functional skill description. It lacks concrete actions the skill performs, has no 'Use when...' clause, and uses aspirational language ('Master proven...') rather than describing what the skill actually does.
Suggestions
Add an explicit 'Use when...' clause with trigger scenarios, e.g., 'Use when the user asks about structuring a backend project, organizing code layers, implementing dependency inversion, or setting up domain-driven design patterns.'
Replace the aspirational framing ('Master proven...') with concrete actions in third person, e.g., 'Guides structuring backend projects using Clean Architecture layers, defines bounded contexts and aggregates for DDD, implements ports-and-adapters patterns.'
Include common user-facing trigger terms and synonyms like 'project structure', 'code organization', 'ports and adapters', 'onion architecture', 'layered architecture', 'service layer', 'repository pattern'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (backend architecture) and some specific patterns (Clean Architecture, Hexagonal Architecture, DDD), but doesn't list concrete actions—'build maintainable, testable, and scalable systems' is aspirational rather than describing specific operations the skill performs. | 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. Per rubric guidelines, missing 'Use when' caps completeness at 2, and the 'what' is also somewhat vague, warranting a 1. | 1 / 3 |
Trigger Term Quality | Includes relevant keywords like 'Clean Architecture', 'Hexagonal Architecture', 'Domain-Driven Design', and 'backend architecture', but misses common user variations like 'ports and adapters', 'layered architecture', 'onion architecture', 'project structure', or 'code organization'. | 2 / 3 |
Distinctiveness Conflict Risk | The mention of specific architecture patterns (Clean, Hexagonal, DDD) provides some distinctiveness, but 'backend architecture patterns' and 'maintainable, testable, scalable systems' are broad enough to overlap with general software design or coding best practices skills. | 2 / 3 |
Total | 7 / 12 Passed |
Implementation
22%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is essentially a high-level outline with no actionable content. It lists abstract steps like 'select an architecture pattern' and 'define module boundaries' without providing any concrete patterns, code examples, templates, or specific guidance. The entire substance is deferred to a referenced playbook file that doesn't exist in the bundle, leaving the skill hollow and unusable.
Suggestions
Add concrete, executable examples for at least one architecture pattern (e.g., a Clean Architecture folder structure with sample code showing dependency direction and interface definitions).
Replace the vague 5-step instructions with specific, actionable workflows — e.g., 'To implement Clean Architecture: 1. Create these layers... 2. Define these interfaces... 3. Validate dependency rules by checking imports...'
Either include the referenced `resources/implementation-playbook.md` in the bundle or inline the essential patterns and checklists directly in the skill body.
Add validation checkpoints to the workflow, such as 'Verify no inner layer imports outer layer modules' or 'Run dependency analysis tool to confirm architecture compliance.'
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The 'Use this skill when' and 'Do not use this skill when' sections add moderate value but are somewhat verbose. The 'Limitations' section contains generic boilerplate that Claude already knows. The instructions themselves are reasonably lean but could be tighter. | 2 / 3 |
Actionability | The instructions are entirely abstract and vague — 'Clarify domain boundaries,' 'Select an architecture pattern,' 'Define module boundaries' — with no concrete code, commands, examples, or specific patterns. There is no executable guidance whatsoever; it describes rather than instructs. | 1 / 3 |
Workflow Clarity | The five numbered steps are high-level and lack any concrete validation checkpoints, feedback loops, or specific sequencing details. Step 4 mentions 'validation checks' but provides no specifics. For a skill covering architecture patterns involving potentially destructive refactoring, this is insufficient. | 1 / 3 |
Progressive Disclosure | The skill references `resources/implementation-playbook.md` for detailed content, which is a good structural choice. However, no bundle files are provided, meaning the referenced file doesn't exist, and the main skill body contains almost no substantive content of its own — it's essentially an empty shell pointing to a missing file. | 2 / 3 |
Total | 6 / 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
- boisenoise/skills-collections
- Commit
95574f3
- 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.