Domain Modeling: The Agent Skill That Keeps Your Ubiquitous Language Honest

Where this fits

You're mid-sprint on an ordering system. Your agent suggests a change to the Order entity, but the term Order means different things to sales, finance, and logistics. The team's glossary lives in a stale CONTEXT.md nobody updates. Without a discipline for pinning down terminology and recording decisions, the model drifts and every conversation gets ambiguous. This skill gives your agent an active role: it challenges vague terms, invents edge-case scenarios, and writes down the ubiquitous language and architectural decisions the moment they crystallise.

Why agents benefit

• Proactive model evolution – Instead of passively reading CONTEXT.md for vocabulary, the agent actively proposes new terms, flags contradictions, and updates the glossary as it designs.
• Automated ADR capture – When a design choice is made (e.g., "we'll use event sourcing for orders"), the agent drafts a numbered ADR and files it under docs/adr/ without being asked.
• Multi-context awareness – If a CONTEXT-MAP.md exists, the agent knows which context it's in and updates the right CONTEXT.md and ADR directory, keeping bounded contexts clean.
• Consistency enforcement – The agent can scan code and docs for out-of-date terms and propose corrections, making the ubiquitous language executable.
• Decision traceability – Every architectural decision is recorded with context and consequences, so future agents can reason about why the model looks the way it does.

Practical scenarios

During event storming

You're mapping a new checkout flow. The agent listens to your descriptions, spots that you use "payment" and "charge" interchangeably, and proposes a glossary entry distinguishing them. It then drafts an ADR for the chosen write model.

When refactoring a bounded context

You split a monolith's ordering module into two contexts. The agent detects the split, creates new CONTEXT.md files, updates the CONTEXT-MAP.md, and rewrites ambiguous terms in the affected code comments.

Onboarding a new agent instance

A fresh agent joins your repo. Instead of asking for context, it reads the map and glossaries, then immediately asks intelligent questions about edge cases the current model doesn't cover—because it's been trained to challenge the model, not just consume it.

Add it to your agent workflow

Install the skill with:

npx skills add tt-a1i/matt-skills-with-to-goal --skill domain-modeling

Then, in your agent prompt, say something like: "We're adding a refund flow. Use the domain-modeling skill to refine the glossary and record any decisions." The agent will read the existing context, propose term changes, and write an ADR for the refund policy.

Compare before adopting

Before you commit, compare this skill against simpler habits: does your agent already maintain a glossary? Does it record ADRs? Check the skill's GitHub for recent commits, issue responsiveness, and star growth (currently 137 stars). Also consider alternatives like a custom prompt that forces glossary updates—but those lack the structured file handling and multi-context logic this skill provides.

Why it is worth tracking

This skill addresses a real pain point: domain models rot when agents only read them. Its active, decision-recording approach is a strong quality signal, and the author's maintenance cadence suggests it's not abandoned. Track it if you're building long-lived agent workflows that touch complex business domains. When your agents start making design choices, you'll want them to leave a trail. For more agent skills like this, see domain-modeling on OpenAgentSkill.