Skip to content
cccskills
FreePublished on GitHubEnglish overview

domain-modeling

Clarify a project's business concepts and terminology through concrete scenarios and comparisons with code. Record agreed definitions in a glossary and document significant design trade-offs in ADRs, records explaining why a decision was made.

OriginalShow the original description

Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.

AI rating100/ 100See how to install

Good for

  • Resolving ambiguous business terms
  • Creating or updating GLOSSARY.md
  • Checking whether code matches business definitions
  • Recording reasons for significant design decisions

Overview

What it does

Clarify the business concepts a project uses and the relationships between them. The skill flags ambiguous terms and conflicts with existing definitions, then uses concrete edge cases to establish where one concept ends and another begins. It also checks explanations against code. Agreed terms go straight into GLOSSARY.md. For significant design decisions, it may suggest an ADR: a document recording the reasons behind a decision.

When it helps

Use it when a word such as “account” has several meanings and makes design discussions confusing. It also helps when creating a glossary or reviewing business definitions. For repositories with several business domains, it uses GLOSSARY-MAP.md to work with each domain's glossary and decision records.

Example requests

  • “Explain the difference between Customer and User with concrete examples, then update the glossary.”
  • “Check whether the partial cancellation explanation matches the code.”
  • “Consider whether this design decision needs an ADR.”

Notes

The glossary contains definitions only, without implementation details or specifications. ADRs are suggested only for decisions that are costly to reverse, difficult to understand without context, and made by comparing real alternatives. Files are created when there is something to record.

This overview was written by AI (OpenAI Codex) from the public SKILL.md. Check the original below for the exact behavior.

Objective evaluation

AI rated this skill on four points using only the contents of its SKILL.md. Stars and popularity are not taken into account.

Clear instructionsIs it clear when to use it and what it does?
AGoodThe instructions specify when to clarify terms, check code, update the glossary, and propose ADRs.
Concrete stepsAre steps, inputs, outputs, and examples spelled out?
AGoodIt provides glossary update instructions, document layout examples, and three conditions for proposing an ADR.
SafetyAre sending data, deleting files, and running commands disclosed?
AGoodGlossary updates record resolved definitions, and ADR creation is offered only when three stated conditions hold.
Easy setupDoes it need few tools or API keys, and are they documented?
AGoodNo dedicated tools or API keys are specified; glossary and ADR locations and creation timing are documented.

The total counts each point as A = 25, B = 15, C = 5. Rated by AI (OpenAI Codex) as of Oct 19, 2026. Treat it as a guide and read the original before installing.

Disagree? Request a re-evaluation

Tell us which point is wrong and why. No login needed. We will check it against the SKILL.md, redo the evaluation, and show the result here.

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

Files included (4)

  • SKILL.md3.3 KB
  • ADR-FORMAT.md2.7 KB
  • agents/openai.yaml101 B
  • GLOSSARY-FORMAT.md2.2 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

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 GLOSSARY.md 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.)

File structure

Most repos have a single context:

/
├── GLOSSARY.md
├── docs/
│   └── adr/
│       ├── 0001-event-sourced-orders.md
│       └── 0002-postgres-for-write-model.md
└── src/

If a GLOSSARY-MAP.md exists at the root, the repo has multiple contexts. The map points to where each one lives:

/
├── GLOSSARY-MAP.md
├── docs/
│   └── adr/                          ← system-wide decisions
├── src/
│   ├── ordering/
│   │   ├── GLOSSARY.md
│   │   └── docs/adr/                 ← context-specific decisions
│   └── billing/
│       ├── GLOSSARY.md
│       └── docs/adr/

Create files lazily: only when you have something to write. If no GLOSSARY.md exists, create one when the first term is resolved. If no docs/adr/ exists, create it when the first ADR is needed.

During the session

Challenge against the glossary

When the user uses a term that conflicts with the existing language in GLOSSARY.md, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y. Which is it?"

Sharpen fuzzy language

When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account': do you mean the Customer or the User? Those are different things."

Discuss concrete scenarios

When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.

Cross-reference with code

When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible. Which is right?"

Update GLOSSARY.md inline

When a term is resolved, update GLOSSARY.md right there. Don't batch these up: capture them as they happen. Use the format in GLOSSARY-FORMAT.md.

GLOSSARY.md should be totally devoid of implementation details. Do not treat GLOSSARY.md as a spec, a scratch pad, or a repository for implementation decisions. It is a glossary and nothing else.

Offer ADRs sparingly

Only offer to create an ADR when all three are true:

  1. Hard to reverse: the cost of changing your mind later is meaningful
  2. Surprising without context: a future reader will wonder "why did they do it this way?"
  3. The result of a real trade-off: there were genuine alternatives and you picked one for specific reasons

If any of the three is missing, skip the ADR. Use the format in ADR-FORMAT.md.

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

ask-matt

FreeSummaryAI rating 90

Choose which related skill to use and in what order for planning, building, debugging, or maintaining software. It explains routes through the available workflows and helps select the next step based on your situation and project size.

  • Choosing a workflow from idea to implementation
  • Finding the right starting point for bug investigation
  • Planning a build that spans multiple sessions
mattpocock/skills298.5KUpdated Oct 20, 2026

chief-of-staff

FreeSummaryAI rating 60

Coordinate subagents, separate agents assigned tasks, to pursue a long-running goal in one session. Maintain dialogue with the user while improving working conditions, shared rules, and access to information needed for future tasks.

  • Coordinating agents around a long-term goal
  • Continuing user dialogue during background work
  • Improving shared rules and working conditions
mattpocock/skills298.5KUpdated Oct 20, 2026

claude-handoff

FreeSummaryAI rating 90

Summarize an ongoing conversation and launch a fresh background agent to continue the work. The handoff includes the next focus, references to existing documents, and suggested skills, with sensitive information removed.

  • Continue ongoing work with a fresh agent
  • Hand off work with a specific next focus
  • Organize document references for the next session
mattpocock/skills298.5KUpdated Oct 20, 2026

code-review

FreeSummaryAI rating 90

Review code changes from a chosen Git reference against two separate criteria: documented coding standards and the original requirements. Independent reviewers check each criterion, then present findings separately so convention problems and requirement gaps remain visible.

  • Reviewing changes on a branch or pull request
  • Checking changes since a chosen commit or tag
  • Checking compliance with documented coding standards
mattpocock/skills298.5KUpdated Oct 20, 2026

codebase-design

FreeSummaryAI rating 90

Design modules that offer substantial behavior through a small interface, the rules callers must understand. Use shared design terms to simplify usage, contain complexity, choose where implementations can vary, and make behavior easier to test.

  • Simplifying a module's interface
  • Bringing scattered complexity into one module
  • Choosing where implementations can be swapped
mattpocock/skills298.5KUpdated Oct 20, 2026

diagnosing-bugs

FreeSummaryAI rating 80

Investigate difficult bugs and performance slowdowns by building a repeatable test or script that detects the exact symptom. Reduce the failing case, compare possible causes, and verify the fix with checks that catch the bug if it returns.

  • Investigating an error that is hard to reproduce
  • Finding the cause of a performance slowdown
  • Testing an intermittent failure repeatedly
mattpocock/skills298.5KUpdated Oct 20, 2026

See all skills by mattpocock

Report a problem with this skill