PluginBench
Skill
Pass
Audit score 90

ubiquitous-language

vinvcn/mattpocock-skills-zh-cn

Extract and formalize domain terminology from conversations into a DDD-style ubiquitous language glossary.

What is ubiquitous-language?

This skill scans conversations for domain-relevant concepts, identifies terminology ambiguities and synonyms, and generates a canonical glossary saved to UBIQUITOUS_LANGUAGE.md. Use it when defining domain terms, building vocabularies, tightening terminology, or creating shared language for domain-driven design.

  • Scans conversations to identify domain-relevant nouns, verbs, and concepts
  • Detects ambiguities (same word for different concepts) and synonyms (different words for same concept)
  • Proposes a canonical glossary with opinionated term selection and aliases to avoid
  • Generates UBIQUITOUS_LANGUAGE.md with structured tables, relationships, and example dialogues
  • Flags conflicting or overloaded terms with explicit recommendations
  • Groups terms into logical clusters (subdomains, lifecycles, actors) with separate tables

How to install ubiquitous-language

npx skills add https://github.com/vinvcn/mattpocock-skills-zh-cn --skill ubiquitous-language
Claude Code
Cursor
Windsurf
Cline

How to use ubiquitous-language

  1. 1.Run the skill when you want to extract domain terminology from the current conversation
  2. 2.The skill scans for domain-relevant concepts and identifies ambiguities or synonyms
  3. 3.Review the generated UBIQUITOUS_LANGUAGE.md file with domain experts to validate definitions
  4. 4.Use the canonical terms and aliases in subsequent conversations and code
  5. 5.Re-run the skill in the same conversation to merge new terms and update definitions as understanding evolves

Use cases

Good for
  • Aligning team terminology during domain modeling discussions to prevent miscommunication
  • Building a shared vocabulary glossary for a new microservice or bounded context
  • Resolving terminology conflicts when the same word means different things to different stakeholders
  • Documenting domain expert knowledge in a format developers can reference during implementation
  • Iteratively refining domain language as understanding evolves across multiple conversations
Who it's for
  • Domain-driven design practitioners and architects
  • Development teams building domain models or bounded contexts
  • Product managers and domain experts documenting business concepts
  • Teams transitioning from informal to formal domain language

ubiquitous-language FAQ

What terms should I include in the glossary?

Include only domain-relevant terms that matter to domain experts and stakeholders. Skip generic programming concepts (array, function, endpoint) unless they have domain-specific meaning. Focus on nouns, verbs, and concepts that represent business or domain logic.

How should I handle terms with multiple meanings?

Flag these explicitly in the 'Flagged ambiguities' section. Choose the most appropriate term as canonical, list other uses as 'aliases to avoid', and explain why they are distinct concepts.

Can I use this skill multiple times on the same conversation?

Yes. The skill reads the existing UBIQUITOUS_LANGUAGE.md, merges new terms from subsequent discussion, updates definitions if understanding evolved, and rewrites the example dialogue to include new terms.

What format does the output use?

The skill generates UBIQUITOUS_LANGUAGE.md with grouped tables (by subdomain/lifecycle/actor), one-sentence definitions, relationship cardinality, and an example dialogue between a developer and domain expert showing terms in natural use.

How opinionated should term selection be?

Be opinionated: when multiple words describe the same concept, select the best one and list others as aliases to avoid. Justify the choice implicitly through clear definitions and relationships.

Full instructions (SKILL.md)

Source of truth, from vinvcn/mattpocock-skills-zh-cn.


name: ubiquitous-language description: 从当前对话提取 DDD 风格的 ubiquitous language glossary,标记歧义并提出标准术语。保存到 UBIQUITOUS_LANGUAGE.md。适用于用户想定义领域术语、构建词汇表、收紧术语、创建通用语言,或提到 “domain model” / “DDD” 时。 disable-model-invocation: true

Ubiquitous Language

从当前 conversation 中提取并形式化 domain terminology,整理成一致 glossary,并保存到本地文件。

Process

  1. Scan the conversation,寻找 domain-relevant nouns、verbs 和 concepts
  2. Identify problems:
    • 同一个词被用于不同 concepts(ambiguity)
    • 不同词被用于同一个 concept(synonyms)
    • 模糊或 overloaded terms
  3. Propose a canonical glossary,对 term 选择保持 opinionated
  4. Write to UBIQUITOUS_LANGUAGE.md,在 working directory 中使用下面格式
  5. Output a summary,在 conversation 中内联总结

Output Format

写一个 UBIQUITOUS_LANGUAGE.md 文件,结构如下:

# Ubiquitous Language

## Order lifecycle

| Term        | Definition                                              | Aliases to avoid      |
| ----------- | ------------------------------------------------------- | --------------------- |
| **Order**   | A customer's request to purchase one or more items      | Purchase, transaction |
| **Invoice** | A request for payment sent to a customer after delivery | Bill, payment request |

## People

| Term         | Definition                                  | Aliases to avoid       |
| ------------ | ------------------------------------------- | ---------------------- |
| **Customer** | A person or organization that places orders | Client, buyer, account |
| **User**     | An authentication identity in the system    | Login, account         |

## Relationships

- An **Invoice** belongs to exactly one **Customer**
- An **Order** produces one or more **Invoices**

## Example dialogue

> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed. A single **Order** can produce multiple **Invoices** if items ship in separate **Shipments**."
> **Dev:** "So if a **Shipment** is cancelled before dispatch, no **Invoice** exists for it?"
> **Domain expert:** "Exactly. The **Invoice** lifecycle is tied to the **Fulfillment**, not the **Order**."

## Flagged ambiguities

- "account" was used to mean both **Customer** and **User** — these are distinct concepts: a **Customer** places orders, while a **User** is an authentication identity that may or may not represent a **Customer**.

Rules

  • Be opinionated. 同一概念有多个词时,选择最好的一个,并把其他列为 aliases to avoid。
  • Flag conflicts explicitly. 如果 term 在 conversation 中被模糊使用,在 "Flagged ambiguities" section 中指出,并给出明确 recommendation。
  • Only include terms relevant for domain experts. 除非 module 或 class 名在 domain language 中有意义,否则跳过。
  • Keep definitions tight. 最多一句。定义它是什么,不定义它做什么。
  • Show relationships. 使用粗体 term names,并在明显时表达 cardinality。
  • Only include domain terms. 跳过 generic programming concepts(array、function、endpoint),除非它们有 domain-specific meaning。
  • Group terms into multiple tables,当自然 clusters 出现时使用(例如按 subdomain、lifecycle 或 actor)。每组有自己的 heading 和 table。如果所有 terms 属于一个 cohesive domain,一个 table 就够,不要强行分组。
  • Write an example dialogue. 写一段 dev 与 domain expert 之间的短对话(3-5 exchanges),展示 terms 如何自然互动。对话应澄清相关 concepts 的边界,并展示精确使用 terms。
<example>

Example dialogue

Dev: "How do I test the sync service without Docker?"

Domain expert: "Provide the filesystem layer instead of the Docker layer. It implements the same Sandbox service interface but uses a local directory as the sandbox."

Dev: "So sync-in still creates a bundle and unpacks it?"

Domain expert: "Exactly. The sync service doesn't know which layer it's talking to. It calls exec and copyIn — the filesystem layer just runs those as local shell commands."

</example>

Re-running

在同一 conversation 中再次调用时:

  1. 读取已有 UBIQUITOUS_LANGUAGE.md
  2. 合并后续讨论中的新 terms
  3. 如果理解演进,更新 definitions
  4. 重新标记任何新 ambiguities
  5. 重写 example dialogue 以纳入新 terms