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.

0.98x

Quality

—

Does it follow best practices?

Impact

97%

0.98x

Average score across 3 eval scenarios

Securityby

Advisory

Suggest reviewing before use

Quality

Content

50%

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 conceptually complete, with concrete directory layouts and code, but it is verbose with already-known concepts and ships examples that are not fully executable. Its progressive-disclosure references point to bundle files that do not exist.

Suggestions

Trim concept explanations Claude already knows (layer/value-object/entity/repository definitions) and keep only the non-obvious guidance, such as the project directory layout and pattern-specific decisions.

Make the code examples runnable end-to-end: add missing imports (field, datetime, List, ABC, stripe) and either give Money an __add__/__radd__ or change Order.total() to fold with Money.add() so it does not silently break.

Either create the referenced references/ and assets/ bundle files and move the long code sections into them, or remove the dangling Resources entries so progressive disclosure points at real, one-level-deep material.

Dimension	Reasoning	Score
Conciseness	The ~490-line body pads known concepts Claude already has (e.g. "Entities: Core business models", "Value Objects: Immutable objects defined by attributes", "Repositories: Data access abstraction"), so it is not lean at 3; but it also supplies real actionable structure and code, keeping it above the fully-verbose 1 anchor.	2 / 3
Actionability	It gives concrete directory structure and substantial code, but the examples are not copy-paste executable — e.g. Order.total() sums Money objects with no __add__, and several files lack imports (OrderRepository uses field/datetime/List undefined; the hexagonal block uses stripe/ABC/Order/OrderResult without definition) — matching the incomplete-guidance 2 anchor rather than the executable 3.	2 / 3
Workflow Clarity	It is organized (concepts -> patterns -> code -> best practices -> pitfalls) but there is no sequenced multi-step process with validation checkpoints for actually applying these patterns, landing on the 2 anchor (sequence present, checkpoints implicit/missing) rather than the 3 anchor with explicit validation.	2 / 3
Progressive Disclosure	A Resources section lists references/clean-architecture-guide.md, references/hexagonal-architecture-guide.md, references/ddd-tactical-patterns.md and assets/clean-architecture-template/, assets/ddd-examples/ — but none of these files exist on disk, so the signaled one-level-deep references are broken, and the inline code that should live in them remains in SKILL.md, fitting the 2 anchor and not the well-split 3 anchor.	2 / 3
	Total	8 / 12 Passed

Description

100%

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: it states a concrete capability with named patterns and pairs a clear 'what' with an explicit 'Use when' trigger, all in third person. It is distinctive and low conflict risk.

Dimension	Reasoning	Score
Specificity	The description names a concrete domain and lists three specific architecture patterns ("Clean Architecture, Hexagonal Architecture, and Domain-Driven Design") plus concrete actions ("Implement", "architecting", "refactoring"), matching the multiple-specific-actions anchor rather than the partial-coverage anchor at 2.	3 / 3
Completeness	It explicitly answers both what ("Implement proven backend architecture patterns including...") and when ("Use when architecting complex backend systems or refactoring existing applications for better maintainability"), with a clear 'Use when' trigger, matching the 3 anchor and not the 2 anchor where 'when' is only implied.	3 / 3
Trigger Term Quality	It uses natural developer-facing terms a user would say ("Clean Architecture", "Hexagonal Architecture", "Domain-Driven Design", "architecting complex backend systems", "refactoring", "maintainability"); it stops short of 2 only in missing a few common variations (e.g. "ports and adapters", "layered architecture"), but coverage is strong enough for 3.	3 / 3
Distinctiveness Conflict Risk	The named-pattern niche (Clean/Hexagonal/DDD backend architecture) and explicit architect/refactor triggers carve a distinct space unlikely to fire for unrelated skills, satisfying the 3 anchor rather than the overlapping 2 anchor.	3 / 3
	Total	12 / 12 Passed

Validation

93%

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

Validation for skill structure

Criteria	Description	Result
referenced_paths_exist	Referenced path issues: 5 missing	Warning

	Total	15 / 16 Passed

Repository: Dicklesworthstone/pi_agent_rust
Commit: abece4a

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