The Skill Everyone's Installing But Few Are Using Correctly
Let's talk numbers. mattpocock's domain-modeling skill has 264,024 stars on SkillsMP and picked up 7,682 of those in the last seven days alone. It's trending "breakout." When a single skill moves that fast, you have to ask: is this just hype, or is there something genuinely useful under the hood?
I've been using this skill across several projects now, and my answer is the latter — with a few honest caveats.
What This Skill Actually Does
The SKILL.md description says it builds and sharpens a project's domain model. But that's a polite way to put it. What it really does is force your AI agent to stop being sloppy with terminology.
Most coding agents will happily use terms like "account," "order," or "customer" interchangeably because they don't actually understand the business boundaries of your application. The domain-modeling skill changes that. It makes the agent:
- Check its language against a project glossary (CONTEXT.md)
- Challenge vague terms the user throws around
- Stress-test domain relationships with invented edge cases
- Cross-reference stated behavior against actual code
- Update documentation inline as terms get resolved
This isn't a passive skill that sits back and lets the agent do whatever. It's an active discipline — it intervenes, pushes back, and demands precision. That's a fundamentally different relationship between the agent and the developer than what most skills provide.
Why It Matters
Here's the gap this skill fills: AI agents are incredibly good at generating code, but they're terrible at understanding why certain terms exist and where the boundaries of a concept are. They'll implement a "partial cancellation" because you asked for it, even if your codebase only supports full cancellation — and they won't flag that contradiction unless you tell them to.
This skill codifies that exact intervention pattern. It turns what should be a natural part of collaborative development — calling out ambiguous language, surfacing contradictions, documenting decisions — into a repeatable, agent-driven process.
The ADR criteria alone are worth the install. An ADR is only offered when it's hard to reverse, surprising without context, and the result of a real trade-off. That's a filter that catches 90% of "should I write an ADR?" hesitation. Most ADRs shouldn't exist. This skill enforces that instinct.
Key Capabilities
1. Glossary enforcement. When you use a term that conflicts with CONTEXT.md, the agent calls it out immediately. Not later, not in a summary — immediately, in the middle of the conversation.
2. Fuzzy language sharpening. "You're saying 'account': do you mean the Customer or the User?" This is the kind of question a senior developer would ask, and the skill makes the agent ask it consistently.
3. Edge-case scenario invention. The agent doesn't just accept your domain relationships at face value. It invents scenarios to probe boundaries. This is where the real value lives — catching conceptual misunderstandings before they become code.
4. Code cross-referencing. If the agent says something works one way but the code says another, it surfaces the contradiction. This is basic diligence that most agents skip entirely.
5. Lazy file creation. CONTEXT.md and docs/adr/ are created only when needed. No empty scaffolding, no premature documentation. Just-in-time writing.
Who Should Install This
If you're building anything with a non-trivial domain — fintech, healthcare, logistics, e-commerce, SaaS with complex business rules — install this immediately. It will save you from the most common failure mode of AI-assisted development: the agent implementing the wrong thing because it didn't understand the domain.
If you're working on a small utility project or a prototype that won't ship, this might feel like overkill. The discipline it enforces assumes you care about long-term maintainability. If you don't, skip it.
If you're already using a structured framework like DDD and have a CONTEXT.md or equivalent, this skill will slot in naturally. If you don't have any domain documentation yet, expect to spend some time building that foundation first — the skill will help you build it, but it can't do it for you in a single session.
How to Install
The simplest path for Claude Code users:
claude plugins install mattpocock-skills
Or, if you prefer editable skill files you can hack on:
npx skills@latest add mattpocock/skills
Then run /setup-matt-pocock-skills in your agent to configure your issue tracker, labels, and doc paths. The skill files land in .claude/skills/ or ~/.claude/skills/ depending on your setup.
Note: the repo also ships CONTEXT-FORMAT.md and ADR-FORMAT.md as companion references. The domain-modeling skill links to them, so make sure you grab the full package.
Concerns and Limitations
Let me be critical for a moment.
First, this skill assumes you already have (or are willing to build) a CONTEXT.md. If your project has zero domain documentation, the first few sessions will feel slow — you're essentially building the glossary while using it. That's fine, but it's not the frictionless experience some skills promise.
Second, the skill's effectiveness depends heavily on the model you're running it against. A weaker model might struggle with the nuance of "sharpening fuzzy language" or inventing meaningful edge cases. On GPT-4-class models or strong Claude instances, it shines. On smaller models, it can feel like the agent is just repeating the instructions back at you without actually engaging.
Third, and this is my biggest honest concern: discipline decays. The skill sets up a great pattern, but if you skip sessions or let CONTEXT.md drift, the whole thing loses its value. The skill can't enforce your discipline — only you can. It's a tool, not a process replacement.
Verdict
Yes, install it. The 264K star count isn't accidental. The skill does something genuinely different from what most agent skills attempt: it treats domain understanding as a first-class concern, not an afterthought. The ADR criteria alone are worth internalizing, even if you don't use the skill full-time.
It's not perfect. It requires upfront investment, it depends on model quality, and it demands your ongoing discipline. But for any project where the domain matters — which is most real software — this is one of the best tools I've added to my workflow this year.
The skill is free, open-source, and ready to go. The only question is whether your agent is ready to think about your domain the way you do.
SkillsMP: https://skillsmp.com/creators/mattpocock/skills/skills-engineering-domain-modeling GitHub: https://github.com/mattpocock/skills/tree/main/skills/engineering/domain-modeling