architecture-patterns

Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems.

Quality

27%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./plugins/antigravity-awesome-skills/skills/architecture-patterns/SKILL.md

Quality

Content

22%Scale 1-3

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 names important architecture patterns (Clean Architecture, Hexagonal, DDD) but provides zero concrete guidance, code examples, or templates for any of them. The referenced `resources/implementation-playbook.md` is missing from the bundle, leaving the skill hollow.

Suggestions

Add concrete, executable examples for at least one architecture pattern (e.g., a Clean Architecture folder structure with sample interface/implementation code in Python or TypeScript).

Replace the vague 5-step instructions with specific, sequenced workflows including validation checkpoints (e.g., 'Verify no inner layer imports outer layer modules by running: grep -r ...').

Provide the referenced `resources/implementation-playbook.md` bundle file, or inline the essential checklists and templates directly in the SKILL.md.

Remove boilerplate sections (Limitations, 'Use this skill when') and use that token budget for actual architectural patterns, decision matrices, and code examples.

Dimension	Reasoning	Score
Conciseness	The 'Use this skill when' and 'Do not use this skill when' sections are somewhat verbose and explain things Claude can infer. The Limitations section is boilerplate. However, the core instructions are reasonably lean.	2 / 3
Actionability	The instructions are entirely abstract and high-level ('Clarify domain boundaries', 'Select an architecture pattern', 'Define module boundaries'). There are no concrete code examples, specific commands, architectural diagrams, or executable guidance. The skill describes rather than instructs.	1 / 3
Workflow Clarity	The five numbered steps are vague directives without concrete details, validation checkpoints, or feedback loops. 'Provide migration steps and validation checks' tells Claude to produce validation but doesn't model what that looks like. There's no clear sequence for multi-step architectural work.	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 SKILL.md itself lacks enough substance to serve as a useful overview pointing to that resource.	2 / 3
	Total	6 / 12 Passed

Description

32%Scale 1-3

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 (what it actually does), explicit trigger guidance (when to use it), and uses aspirational language ('Master proven...') rather than describing capabilities in third person active voice.

Suggestions

Add an explicit 'Use when...' clause with trigger scenarios, e.g., 'Use when the user asks about structuring a backend project, implementing Clean Architecture, Hexagonal Architecture, DDD bounded contexts, or organizing code layers.'

Replace the aspirational framing ('Master proven...') with concrete actions in third person, e.g., 'Structures backend projects using Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Defines bounded contexts, implements ports and adapters, and organizes domain layers.'

Include common keyword variations users might naturally say, such as 'DDD', 'ports and adapters', 'onion architecture', 'project structure', 'code organization', or 'layered architecture'.

Dimension	Reasoning	Score
Specificity	Names the domain (backend architecture) and some specific patterns (Clean Architecture, Hexagonal Architecture, DDD), but describes outcomes ('maintainable, testable, scalable') rather than concrete actions like 'structure project layers', 'define bounded contexts', or 'implement ports and adapters'.	2 / 3
Completeness	Describes what the skill covers (architecture patterns) but completely lacks any 'Use when...' clause or explicit trigger guidance for when Claude should select this skill. Per rubric guidelines, a missing 'Use when...' clause caps completeness at 2, and the 'what' is also somewhat vague, warranting a score of 1.	1 / 3
Trigger Term Quality	Includes relevant keywords like 'Clean Architecture', 'Hexagonal Architecture', and 'Domain-Driven Design' that users might mention, but misses common variations like 'ports and adapters', 'onion architecture', 'DDD', 'layered architecture', 'project structure', or 'separation of concerns'.	2 / 3
Distinctiveness Conflict Risk	The mention of specific architecture patterns (Clean, Hexagonal, DDD) provides some distinctiveness, but 'backend architecture' is broad enough to overlap with general coding skills, project scaffolding skills, or design pattern skills.	2 / 3
	Total	7 / 12 Passed

Validation

90%

Warnings & errors only

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: popey/claude-code-skills
Path: plugins/antigravity-awesome-skills/skills/architecture-patterns/SKILL.md
Commit: a5a6601

Reviewed: 5 days ago

Table of Contents

Discovery Implementation Validation

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.