domain-modeling
Domain Modeling helps you actively construct and refine your project's domain model by establishing canonical terminology and recording architectural decisions. It guides you to challenge vague language, stress-test domain relationships with concrete scenarios, and maintain a glossary of precise, implementation-free terms that your team can reference.
Domain Modeling helps you build and maintain a shared glossary of canonical domain terminology for your project.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-07-27
Domain Modeling helps you build and maintain a shared glossary of canonical domain terminology for your project. Domain Modeling helps you actively construct and refine your project's domain model by establishing canonical terminology and recording architectural decisions. It guides you to challenge vague language, stress-test domain relationships with concrete scenarios, and maintain a glossary of precise, implementation-free terms that your team can reference.
Use it when
- Domain Modeling emphasizes building a ubiquitous language glossary to establish shared vocabulary across your team and codebase.
- Domain Modeling actively challenges and sharpens fuzzy or conflicting terminology during design by encouraging you to articulate precise.
Verify before relying
Read SKILL.md below before installing (1 file). Open directory: indexed for reading, not audited.
Similar skills
Install
frankify-app/skills/domain-modeling · repository language: Shell
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How do I build a domain model for my project?
Domain Modeling guides you through constructing a shared domain model by establishing canonical terminology and recording architectural decisions. Start by identifying core concepts in your problem space, challenge vague language with your team, and document precise, implementation-free terms in a glossary. Domain Modeling helps you stress-test relationships with concrete scenarios and maintain a reference that keeps your codebase aligned with your domain understanding.
What is the purpose of creating a ubiquitous language glossary?
Domain Modeling emphasizes building a ubiquitous language glossary to establish shared vocabulary across your team and codebase. A canonical glossary reduces ambiguity, ensures everyone uses terms consistently, and bridges communication between domain experts and developers. Domain Modeling helps you document these terms in a structured way and version-control them alongside your code, so your domain language evolves deliberately rather than drifting.
How can Domain Modeling help sharpen fuzzy domain language?
Domain Modeling actively challenges and sharpens fuzzy or conflicting terminology during design by encouraging you to articulate precise definitions and test them against real scenarios. When you encounter vague terms, Domain Modeling prompts you to stress-test domain relationships with edge cases, exposing gaps in your understanding. This process forces clarity and helps your team converge on canonical terms before they calcify in code.
How do I document my domain model and maintain it?
Domain Modeling provides a structured approach to documenting domain concepts, relationships, and architectural decisions. Record your glossary in markdown or your preferred format, version-control it with your codebase, and cross-reference related concepts. Domain Modeling encourages you to validate your documented model against actual implementation and update it as your understanding evolves, keeping documentation and code in sync.
What is domain modeling best practices for software projects?
Domain Modeling emphasizes establishing canonical terminology early, challenging vague language collaboratively, and documenting domain model decisions explicitly. Best practices include stress-testing domain relationships with concrete edge-case scenarios, maintaining a shared glossary your team references, and validating your model against code implementation. Domain Modeling treats your glossary as a living artifact that guides design and keeps your team aligned on what terms actually mean.
How does Domain Modeling help validate my model against code?
Domain Modeling encourages you to stress-test your domain relationships and validate documented concepts against actual implementation. By maintaining a canonical glossary and cross-referencing related concepts, you can spot misalignments between your design-time model and runtime code. Domain Modeling prompts you to use edge-case scenarios to expose gaps, ensuring your codebase faithfully reflects your domain understanding and terminology.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Domain Modeling
Actively build and sharpen the project's domain model as you design. This is the active discipline — challenging terms, inventing edge-case scenarios, and writing the glossary and decisions down the moment they crystallise. (Merely reading the glossary for vocabulary is not this skill — that's a one-line habit any skill can do. This skill is for when you're changing the model, not just consuming it.)
The domain model lives in two places:
- Glossary —
docs/glossary/, one markdown file per term, in the
(truncated - see the full file via the links below)
File tree — 1 file
derived/domain-modeling/SKILL.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Build and maintain a shared domain glossary with canonical terminology”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
This skill guides you through writing Architecture Decision Records—concise documents that capture the shape of load-bearing choices, why you made them, and what trade-offs you considered. Use it when a decision is hard to reverse, surprising without context, or the result of genuine alternatives. ADRs live in docs/adr/ with sequential numbering and a simple template; most need just a paragraph.
tdd guides you through writing tests before implementation using the red-green-refactor workflow. Each cycle commits a failing test marked red, then minimal passing code marked green, with refactoring only after all tests pass. The skill enforces behavioral testing over implementation details and includes commit hygiene checks to keep your tree lint-clean at every step.
This skill guides you through building production-ready MCP servers using the mcp-use framework. Learn to scaffold projects with templates, define tools and resources, create reusable prompts, test locally with the Inspector UI, and deploy to mcp-use Cloud.
DataModelLM is a visual editor for building database schemas in Prisma format, rendering them as entity-relationship diagrams on an interactive canvas. Define models, relationships, and constraints through a structured schema file, then view the resulting data structure graphically. Supports one-to-many, one-to-one, and many-to-many relationships with full Prisma type and attribute support.
This skill transforms 3D Gaussian Splatting representations into parametric CAD models, enabling designers and engineers to work with extracted geometry in standard modeling tools. By bridging the gap between neural scene representations and traditional CAD workflows, it streamlines the process of converting spatial data into editable, structured models for further design iteration.
Create MCP servers that expose capabilities to AI clients through a structured development process covering tool definition, resource management, prompt templates, and transport configuration. The skill guides you through design decisions, implementation patterns, security hardening, and testing to deploy servers ready for CLI and web environments.