Name: kotlin-backend-jpa-entity-mapping
Rating: 74.4 (1 reviews)
Author: Kotlin

kotlin-backend-jpa-entity-mapping

Model Kotlin persistence code correctly for Spring Data JPA and Hibernate. Covers entity design, identity and equality, uniqueness constraints, relationships, fetch plans, and common ORM (Object-Relational Mapping) traps specific to Kotlin. Use when creating or reviewing JPA (Java Persistence API) entities, diagnosing N+1 or LazyInitializationException, placing indexes and uniqueness rules, or preventing Kotlin-specific bugs such as data class entities and broken equals/hashCode.

Quality

91%

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

Quality

Content

83%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 lean and highly actionable, with executable Kotlin examples contrasting broken vs. correct patterns for the key Kotlin/JPA traps. Its main weakness is workflow clarity: guidance is topical rather than sequenced, with no explicit review checklist or validation checkpoints tying the rules into a process.

Suggestions

Add a short 'Review checklist' or ordered workflow (e.g., 1. confirm no data class entity, 2. verify ID-based equals/hashCode, 3. check uniqueness constraints exist at DB+app layers, 4. confirm fetch plan / N+1 diagnosis) to give the rules a clear application sequence.

Add an explicit validation/verification step for destructive or batch operations (e.g., 'after bulk updates/deletes, warn that subsequent reads may be stale and re-query') to satisfy the feedback-loop expectation for database operations.

Consider extracting the 'Common ORM Traps' list into a references file if the skill grows, so SKILL.md stays an overview with one-level-deep pointers.

Dimension	Reasoning	Score
Conciseness	Lean, rule-based, and expert-targeted: no padding about what JPA/Hibernate are, no basic-concept explanations; every section adds Kotlin-specific non-obvious traps with tight code. Minor duplication between inline comments and 'Key rules' bullets, but each adds the rationale concisely.	5 / 5
Actionability	Provides complete, executable Kotlin code for both broken and correct cases across entities, ID-based equality, uniqueness constraints, repository derivation, and service guards — copy-paste ready and covering the common cases.	5 / 5
Workflow Clarity	Content is organized topically (Entity Design, Identity, Uniqueness, Query, Traps, Guardrails) rather than as a sequenced review/design process, and lacks explicit validation checkpoints or a feedback loop; the N+1 rule hints at verification but no ordered workflow ties the rules together.	3 / 5
Progressive Disclosure	Well-organized into clear sections with header navigation; all content is appropriately inline for a focused single-file skill and no external references are needed, though no bundle files are used to split the deeper detail.	4 / 5
	Total	17 / 20 Passed

Description

100%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 third-person, lean, and explicit: it states concrete capabilities and gives a clear 'Use when' clause with natural trigger terms specific to the Kotlin/JPA niche. It distinguishes itself sharply from generic persistence skills.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete capabilities — entity design, identity/equality, uniqueness constraints, relationships, fetch plans — plus specific tasks like diagnosing N+1/LazyInitializationException and placing indexes; comprehensive coverage of the niche.	5 / 5
Completeness	Explicitly answers both 'what' (model Kotlin persistence code correctly, covering entity design, identity, constraints, relationships, fetch plans, traps) and 'when' (explicit 'Use when...' clause with concrete trigger phrases).	5 / 5
Trigger Term Quality	Includes natural phrases a Kotlin/JPA developer would actually say ('creating or reviewing JPA entities', 'diagnosing N+1', 'LazyInitializationException', 'data class entities', 'broken equals/hashCode') with synonyms and expansions (JPA/Java Persistence API, ORM).	5 / 5
Distinctiveness Conflict Risk	Clearly scoped to Kotlin + Spring Data JPA + Hibernate with highly specific triggers (N+1, LazyInitializationException, data class entities, broken equals/hashCode); minimal overlap risk with other skills.	5 / 5
	Total	20 / 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: Kotlin/kotlin-agent-skills
Path: skills/kotlin-backend-jpa-entity-mapping/SKILL.md
Commit: c2f9069

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