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.

Quality

44%

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 ./.agent/skills/architecture-patterns/SKILL.md

Quality

Content

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 thin wrapper that defers all meaningful content to external files that aren't provided. It lacks any concrete, actionable guidance—no code examples, no specific architectural patterns explained, no decision frameworks, and no validation steps. The body reads more like a table of contents than a skill that could guide Claude through architectural decisions.

Suggestions

Add concrete, actionable content directly in the SKILL.md: include at least one executable example of each architecture pattern (e.g., a Clean Architecture folder structure with sample code showing dependency direction).

Define explicit validation checkpoints in the workflow, such as 'Verify no domain layer imports from infrastructure' with a specific grep command or test to run.

Include a decision matrix or concrete criteria for choosing between Clean Architecture, Hexagonal Architecture, and DDD rather than the vague 'Select an architecture pattern that fits the domain complexity'.

Provide the referenced bundle files (implementation-playbook.md) or inline the essential content so the skill is self-contained enough to be useful on its own.

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 'Master proven backend architecture patterns...' intro sentence is unnecessary padding. However, the instructions section itself is reasonably lean.	2 / 3
Actionability	The skill provides no concrete code, commands, specific examples, or executable guidance. The four instruction steps are abstract and vague (e.g., 'Clarify domain boundaries', 'Select an architecture pattern'). All substantive content is deferred to a referenced playbook that isn't provided.	1 / 3
Workflow Clarity	The four steps are extremely high-level with no validation checkpoints, no concrete sequencing details, no error recovery, and no specifics about what 'validation checks' in step 4 actually entail. For a skill involving complex architectural refactoring (a potentially destructive multi-step process), this is insufficient.	1 / 3
Progressive Disclosure	The skill references `resources/implementation-playbook.md` and a sub-skill, which is a reasonable structure. However, no bundle files are provided, so we can't verify the references exist. The SKILL.md itself contains almost no substantive content—it's essentially an empty shell pointing elsewhere, which means the overview itself fails to provide a useful quick-start or summary.	2 / 3
	Total	6 / 12 Passed

Description

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.

The description has a solid structure with an explicit 'Use when' clause and names specific architecture patterns, which is good. However, it lacks concrete action verbs beyond 'implement' and 'refactoring', and the trigger terms could be expanded to include common abbreviations and related concepts. The description could be more distinctive by specifying what concrete outputs or artifacts it produces.

Suggestions

Add more concrete actions such as 'define bounded contexts, create port/adapter interfaces, separate domain logic from infrastructure, structure project layers'.

Expand trigger terms to include common variations like 'DDD', 'ports and adapters', 'onion architecture', 'layered architecture', 'dependency inversion', 'separation of concerns'.

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 specifics like 'define bounded contexts, create port/adapter interfaces, separate domain from infrastructure layers.'	2 / 3
Completeness	Clearly answers both 'what' (implement Clean Architecture, Hexagonal Architecture, DDD patterns) and 'when' (when architecting complex backend systems or refactoring existing applications for better maintainability) with an explicit 'Use when' clause.	3 / 3
Trigger Term Quality	Includes relevant terms like 'Clean Architecture', 'Hexagonal Architecture', 'Domain-Driven Design', 'backend systems', and 'refactoring', but misses common variations users might say such as 'ports and adapters', 'onion architecture', 'DDD', 'layered architecture', 'separation of concerns', or 'dependency inversion'.	2 / 3
Distinctiveness Conflict Risk	While the specific architecture pattern names provide some distinctiveness, terms like 'backend systems', 'refactoring', and 'maintainability' are broad enough to overlap with general backend development skills, code refactoring skills, or design pattern skills.	2 / 3
	Total	9 / 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: Dokhacgiakhoa/antigravity-ide
Path: .agent/skills/architecture-patterns/SKILL.md
Commit: c4a059b

Reviewed: about 2 hours 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.