build-data-model

Design normalized relational data models from plain-language domain requirements.

Updated Feb 15, 2026
One-click install
npx skills add https://github.com/abranjith/spec-lite --skill build-data-model
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: build-data-model
Source: https://github.com/abranjith/spec-lite/tree/main/skills/build-data-model
Command: npx skills add https://github.com/abranjith/spec-lite --skill build-data-model

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) and assets (resource) components.

What problem does it solve?

This Skill turns plain-language domain requirements into a precise relational data model, reducing schema ambiguity and helping teams define the persistence layer before implementation begins.

Core Features & Use Cases

  • Entity Modeling: Identifies tables, columns, keys, and relationships from business descriptions or plan artifacts.
  • Constraint and Index Design: Adds practical constraints, defaults, and indexes based on the target database and expected access patterns.
  • Design Rationale: Documents trade-offs, normalization choices, and migration ordering so downstream implementation stays consistent.
  • Use Case: A team describing users, projects, tasks, and tags can use this Skill to produce a reviewable schema spec that Feature and Implement skills can follow without guessing.

Quick Start

Provide the domain description, target database, and any project memory or plan context, and ask this Skill to draft the relational data model.

Frequently Asked Questions about build-data-model

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

FAQPage Schema
How do I design a relational database schema from plain text requirements?

Designing a relational database schema from plain text involves identifying tables, columns, keys, and relationships from your domain description. This Skill normalizes plain-language requirements into precise table definitions, indexes, and constraints aligned with your target RDBMS.

What is the best way to model entity relationships and constraints for a new application?

Modeling entity relationships and constraints requires identifying tables and applying practical defaults based on expected access patterns. This Skill translates business descriptions into a reviewable relational schema spec, documenting normalization choices and trade-offs for downstream implementation.

Can I generate database indexes and lookup structures from a business workflow description?

Yes, you can generate database indexes and lookup structures from a business workflow description. This Skill analyzes your domain requirements and target database to add practical constraints, defaults, and indexes tailored to your expected data access patterns.

Does this data modeling approach work for evolving an existing application schema?

Yes, this data modeling approach works for evolving an existing application schema. It applies to planning and evolving schemas by producing precise table definitions and migration ordering rationale, ensuring downstream implementation stays consistent without guessing.

How do I document normalization choices and trade-offs when designing a relational data model?

Documenting normalization choices and trade-offs when designing a relational data model involves capturing the design rationale alongside table definitions. This Skill outputs design rationale documenting trade-offs, normalization choices, and migration ordering for your target RDBMS.