spring-data-jpa
Rules and guidelines for working with Spring Data JPA in the project. ALWAYS use this skill when adding, removing, or modifying JPA entities, repositories, or projections. Trigger on any request that involves changing entity structure, adding new entities, modifying field annotations, updating database mappings, creating or modifying Spring Data repositories, or defining query projections (interfaces, DTOs).
68
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 strong skill description with excellent trigger coverage and completeness. It clearly defines when to use the skill with explicit trigger conditions and domain-specific terminology. The main weakness is that it frames itself as 'rules and guidelines' rather than listing specific concrete actions it performs, which slightly reduces specificity.
Suggestions
Replace 'Rules and guidelines for working with' with specific actions like 'Defines entity class structure, configures field annotations and database mappings, creates Spring Data repositories and query projections' to improve specificity.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (Spring Data JPA) and mentions several areas (entities, repositories, projections, field annotations, database mappings), but it describes 'rules and guidelines' rather than listing concrete actions the skill performs. It tells you what it covers but not specific operations it enables. | 2 / 3 |
Completeness | Clearly answers both 'what' (rules and guidelines for Spring Data JPA work) and 'when' with an explicit and detailed trigger clause: 'ALWAYS use this skill when adding, removing, or modifying JPA entities, repositories, or projections. Trigger on any request that involves...' with a comprehensive list of trigger scenarios. | 3 / 3 |
Trigger Term Quality | Excellent coverage of natural trigger terms: 'JPA entities', 'repositories', 'projections', 'entity structure', 'field annotations', 'database mappings', 'Spring Data repositories', 'query projections', 'interfaces', 'DTOs'. These are terms a developer would naturally use when working in this domain. | 3 / 3 |
Distinctiveness Conflict Risk | Highly distinctive with a clear niche around Spring Data JPA specifically. The trigger terms (JPA entities, repositories, projections, database mappings, field annotations) are specific enough to avoid conflicts with general coding skills or other framework-specific skills. | 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 well-structured routing skill that efficiently directs Claude to the right reference files based on the task type. Its strengths are clear workflow sequencing, conditional logic (memory check before file reads), and a concrete output template for reviews. Its main weakness is that all substantive guidance is delegated to reference files that aren't provided in the bundle, making it impossible to verify the skill delivers complete, actionable instructions end-to-end.
Suggestions
Provide the referenced bundle files (references/entity-conventions.md, references/entity-rules-impl.md, references/transaction-conventions.md, references/transaction-rules-impl.md) so the skill can be evaluated as a complete unit
Consider adding a brief inline example of a correctly annotated entity or a key rule summary so the skill provides some immediate actionable value even before reference files are read
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The content is lean and efficient. It doesn't explain what JPA is, what entities are, or how Spring Data works. Every line serves a purpose — routing to the right reference file or defining a specific output format. No wasted tokens. | 3 / 3 |
Actionability | The skill provides clear routing logic (check memory → read conventions → read rules) and a concrete output format for reviews, but all actual implementation details are delegated to reference files. The skill itself contains no executable code, specific commands, or concrete examples of entity code. The review output template is actionable, but the core guidance is indirect. | 2 / 3 |
Workflow Clarity | Each workflow (entity creation/modification, review, transactions) has a clearly sequenced multi-step process with conditional logic (check memory first, then detect conventions, then apply rules). The review workflow includes an explicit output format. Steps are numbered and unambiguous. | 3 / 3 |
Progressive Disclosure | The skill references four external files (entity-conventions.md, entity-rules-impl.md, transaction-conventions.md, transaction-rules-impl.md) which is good progressive disclosure structure. However, no bundle files were provided to verify these references exist, and the references directory naming is consistent but we cannot confirm the files are present. The skill itself is appropriately an overview/router, but the lack of verifiable bundle files limits confidence. | 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
- Amplicode/spring-skills
- Commit
1dd96ad
- 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.