design-patterns

Common design patterns with Java examples (Factory, Builder, Strategy, Observer, Decorator, etc.). Use when user asks "implement pattern", "use factory", "strategy pattern", or when designing extensible components.

Quality

83%

Does it follow best practices?

Impact

—

No eval scenarios have been run

Securityby

Passed

No known issues

Quality

Content

77%

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

This is a solid, actionable design patterns reference with excellent executable Java examples and good organizational structure via tables and clear headings. Its main weakness is that it's quite long for a single SKILL.md—the full implementations of 6 patterns inline consume significant tokens that could be better managed through progressive disclosure to separate files. The anti-patterns table at the end is a nice practical addition.

Suggestions

Consider splitting detailed pattern implementations into separate files (e.g., patterns/builder.md, patterns/strategy.md) and keeping only the quick reference table and 2-3 line summaries in SKILL.md

Remove the duplicate pattern selection table at the bottom since the quick reference table at the top already covers the same mapping

Dimension	Reasoning	Score
Conciseness	The content is mostly efficient with good code examples and tables, but it's quite lengthy for a reference skill. Some patterns (like showing both a plain Factory and Spring version) add bulk. The problem statements before each pattern are helpful but slightly redundant given the quick reference table at the top.	2 / 3
Actionability	Every pattern includes fully executable Java code with usage examples. The code is concrete, copy-paste ready, and includes both interface definitions and client usage. The Spring-specific variants (Observer with @EventListener, Factory with DI) add practical real-world applicability.	3 / 3
Workflow Clarity	This is a reference/catalog skill rather than a multi-step workflow skill. The pattern selection guides (two tables) clearly direct the user to the right pattern for their situation. The structure flows logically from quick reference → creational → behavioral → structural → selection guide → anti-patterns.	3 / 3
Progressive Disclosure	The content is well-structured with clear sections and headers, but it's a monolithic file with ~200 lines of code examples that could benefit from splitting detailed implementations into separate files. A leaner SKILL.md with the quick reference table and brief snippets, linking to per-pattern detail files, would be more token-efficient.	2 / 3
	Total	10 / 12 Passed

Description

89%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

This is a solid skill description with strong trigger terms and a clear 'Use when' clause that covers both specific phrases and a broader use case. Its main weakness is that the 'what' portion is somewhat passive — it describes what the skill contains (patterns with examples) rather than what concrete actions it performs (e.g., generating implementations, explaining when to use each pattern). Overall it's effective for skill selection.

Suggestions

Replace the passive 'Common design patterns with Java examples' with active verbs describing concrete actions, e.g., 'Generates Java implementations of design patterns, explains when to apply each, and refactors existing code to use patterns.'

Dimension	Reasoning	Score
Specificity	Names the domain (design patterns) and lists several specific patterns (Factory, Builder, Strategy, Observer, Decorator), but doesn't describe concrete actions beyond 'common design patterns with Java examples' — it doesn't say what it does with them (e.g., 'generates implementations', 'explains tradeoffs', 'refactors code to use').	2 / 3
Completeness	Clearly answers both 'what' (common design patterns with Java examples, listing specific patterns) and 'when' (explicit 'Use when' clause with trigger phrases and a broader scenario of designing extensible components).	3 / 3
Trigger Term Quality	Includes natural trigger terms users would say: 'implement pattern', 'use factory', 'strategy pattern', 'designing extensible components', plus specific pattern names like Factory, Builder, Strategy, Observer, Decorator. These closely match how users naturally phrase requests.	3 / 3
Distinctiveness Conflict Risk	The combination of 'design patterns' + 'Java' + specific pattern names creates a clear niche that is unlikely to conflict with other skills. The trigger terms are specific to this domain.	3 / 3
	Total	11 / 12 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 — 11 / 11 Passed

Validation for skill structure

No warnings or errors.

Repository: piomin/claude-ai-spring-boot
Commit: d87e7a3

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