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

64%

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

Quality

Content

50%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The body is well-structured and concise but weak on actionability: the instructions are abstract directions with no concrete method, and the single detailed reference it leans on is a missing file. Validation is mentioned but not built into the workflow as a checkpoint.

Suggestions

Replace the abstract Instructions with concrete, actionable guidance — e.g., decision criteria for choosing between Clean/Hexagonal/DDD based on domain complexity, or an inline skeleton of module/dependency-rule templates — so Claude has specific steps rather than high-level verbs.

Add an explicit validation checkpoint to the workflow (e.g., 'After defining boundaries, verify dependencies point inward and no domain layer imports infrastructure'), turning step 4 into a real validate-then-proceed gate.

Create the referenced `resources/implementation-playbook.md` (or remove the dangling reference) so the one-level-deep progressive disclosure actually resolves; currently the detail target does not exist.

Dimension	Reasoning	Score
Conciseness	The body is lean and does not explain concepts Claude already knows, but the opening line nearly restates the frontmatter description and the `resources/implementation-playbook.md` reference is duplicated in both Instructions and Resources, which are minor instances of padding that could be trimmed, fitting 4 rather than the fully-lean 5.	4 / 5
Actionability	The Instructions are high-level hints ("Select an architecture pattern that fits the domain complexity", "Define module boundaries, interfaces, and dependency rules") with no concrete selection criteria, templates, or specific steps to execute, matching the 2 anchor of minimal concrete guidance; it is not 3 because there is no concrete detail or example beyond abstract verbs.	2 / 5
Workflow Clarity	A four-step sequence is listed (clarify, select, define, provide migration) so a sequence is present, but validation checkpoints are only implicit (step 4 mentions "validation checks" as something to provide rather than as a workflow checkpoint) and there is no validate-fix-retry loop, matching the 3 anchor rather than the most-checkpoints-present 4.	3 / 5
Progressive Disclosure	The sections are well organized and the reference is clearly signaled and one level deep, but the referenced `resources/implementation-playbook.md` does not exist (no resources/ directory), so navigation to the detailed material is broken; scoring against the actual (absent) bundle structure caps this at 3 rather than 4.	3 / 5
	Total	12 / 20 Passed

Description

78%Weight 40%Scale 1-5

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 is strong: third-person voice, explicit what-and-when with concrete trigger phrases, and a clear niche. Its main weakness is specificity, since the verbs are generic even though the named patterns are concrete.

Dimension	Reasoning	Score
Specificity	The description names three concrete patterns ("Clean Architecture, Hexagonal Architecture, and Domain-Driven Design") but the actions are generic ("Implement", "refactoring existing applications for better maintainability"), so it lists the domain plus a few concrete items without comprehensive actions, matching the 3 anchor rather than the multiple-specific-actions of 4.	3 / 5
Completeness	It explicitly 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 concrete trigger phrases, matching the 5 anchor.	5 / 5
Trigger Term Quality	Natural phrases a developer would say are present ("architecting complex backend systems", "refactoring existing applications", "better maintainability") alongside named patterns, giving good coverage, though some synonyms (e.g. microservices, decoupling, layered architecture) are missing so it stops short of 5.	4 / 5
Distinctiveness Conflict Risk	The backend-architecture-patterns niche with named approaches is mostly distinct and unlikely to trigger for unrelated skills, but there is minor overlap risk with closely related general refactoring or software-design skills, fitting the 4 anchor rather than the minimal-conflict 5.	4 / 5
	Total	16 / 20 Passed

Validation

100%

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 — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: rmyndharis/antigravity-skills
Path: skills/architecture-patterns/SKILL.md
Commit: 3eff4af

Reviewed: 15 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.