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.
86
83%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Quality
Discovery
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 |
Implementation
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 |
Validation
100%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
Table of Contents
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.