verify-entity-parity

Validate data consistency across Kotlin entities, SQL schemas, and TypeScript types.

Updated May 29, 2026
One-click install
npx skills add https://github.com/peppone-choi/opensamguk --skill verify-entity-parity
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: verify-entity-parity
Source: https://github.com/peppone-choi/opensamguk/tree/main/.claude/skills/verify-entity-parity
Command: npx skills add https://github.com/peppone-choi/opensamguk --skill verify-entity-parity

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill ensures that your backend entities, frontend TypeScript types, and database schemas are perfectly aligned, preventing bugs caused by data inconsistencies.

Core Features & Use Cases

  • Cross-Layer Validation: Verifies that core data structures (like stats, naming conventions, and foreign keys) are consistent across your Kotlin backend, SQL database, and TypeScript frontend.
  • Naming Convention Enforcement: Checks for adherence to specific naming rules (e.g., intel vs. intelligence, crew vs. soldiers).
  • Use Case: After adding a new game entity or modifying an existing one, run this Skill to automatically catch any discrepancies in its representation across the backend code, database schema, and frontend types, ensuring a smooth integration.

Quick Start

Run the entity parity verification to check for consistency between backend, frontend, and database.

Frequently Asked Questions about verify-entity-parity

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I validate data consistency between Kotlin JPA entities and TypeScript types?

To validate data consistency between Kotlin JPA entities and TypeScript types, run a cross-layer verification. This process automatically checks that core data structures, field naming conventions, and foreign key constraints align perfectly across your backend, database schema, and frontend.

What is cross-layer entity validation for database schemas and frontend types?

Cross-layer entity validation ensures data structures like game statistics remain consistent across SQL migrations, Kotlin backend entities, and TypeScript frontend interfaces. It prevents integration bugs by enforcing alignment and specific naming conventions between the database, backend, and frontend layers.

How do I enforce specific naming conventions like intel vs intelligence across backend and frontend?

You can enforce specific naming conventions like intel versus intelligence by running an entity parity verification. It automatically checks for adherence to predefined naming rules across your Kotlin backend, SQL database schemas, and TypeScript frontend interfaces simultaneously.

When do I need to check entity parity across SQL migrations and TypeScript interfaces?

You need to check entity parity after adding a new game entity or modifying an existing one. Running this verification catches discrepancies in the entity's representation across SQL migrations, backend code, and frontend types, ensuring smooth feature integration.

Does this entity validation tool check foreign key constraints in SQL and Kotlin?

Yes, this entity validation tool checks foreign key constraints in SQL and Kotlin. It validates that these constraints and other core data structures are consistent across your SQL database schemas, Kotlin JPA entities, and TypeScript frontend types.