domain-exploration
Use this skill when a user needs to understand a business problem or requirement, discover the relevant domain concepts, or determine whether the work belongs to one bounded context or several. Trigger phrases include "explore this domain", "identify the bounded contexts", "is this one BC or multiple BCs", "help me understand this requirement", "break this problem into domains", and "where does this feature belong". This skill is interactive and confirmation-gated. It does not produce source code or detailed BC specifications.
- License 许可
- MIT
- 最近更新
- 2026-11-03
- Stars
- ★ 7
- Forks
- 0
01 前言 Front Matter
- name
- domain-exploration
- context
- fork
- description
- Use this skill when a user needs to understand a business problem or requirement, discover the relevant domain concepts, or determine whether the work belongs to one bounded context or several. Trigger phrases include "explore this domain", "identify the bounded contexts", "is this one BC or multiple BCs", "help me understand this requirement", "break this problem into domains", and "where does this feature belong". This skill is interactive and confirmation-gated. It does not produce source code or detailed BC specifications.
02 资源文件 4
- 资产文件assets/context-map-template.md1.6 KB
- 资产文件assets/domain-map-template.md2.2 KB
- 资产文件assets/hgate-project-template.json251 B
- 参考文档decisions.md954 B
03 SKILL.md 正文
Domain Exploration
Purpose
Turn an unclear problem or requirement into a user-confirmed domain and bounded context map. Discover the business language, capabilities, rules, actors, outcomes, ownership boundaries, and cross-context relationships before detailed BC refinement begins.
This is a collaborative discovery process, not an autonomous classification exercise. The AI should provide analysis and recommendations, but the user confirms every material conclusion.
Input
At minimum:
- A problem, requirement, product idea, or business outcome to explore
- Any known actors, systems, constraints, or existing domains
Useful supporting evidence includes:
- Existing domain documentation and glossaries
- User journeys and business processes
- Current source code, APIs, events, schemas, and architecture diagrams
- Organization or team ownership
- Known policies, regulations, and external-system contracts
Do not require technical artifacts when the user is still describing a new business capability.
Output
A confirmed Domain Exploration Report containing:
- Problem statement and desired outcomes
- Scope and non-goals
- Ubiquitous language glossary
- Business capabilities and rules
- Proposed domains and bounded contexts
- Core, Supporting, or Generic classification
- Context relationships and integration needs
- Single-BC or multi-BC conclusion
- Open gaps, assumptions, and deferred questions
- Recommended next hGATE skill for each BC
The report is a discovery handoff. It is not a replacement for the specification
files produced by bc-refinement.
When repository access is available, persist the confirmed output as:
docs/domain-map.md, created fromassets/domain-map-template.mddocs/context-map.md, created fromassets/context-map-template.mddocs/hgate-project.json, the deterministic machine-readable projection of the confirmed maps and BC-local authoritative artifacts.github/skills/<bc-name>/status.mdfor each confirmed BC, created from thebc-refinementstatus template with lifecycleDISCOVERED
If an artifact already exists, update only confirmed boundary changes. Do not overwrite unrelated BC entries or lifecycle history.
The Markdown maps, BC specifications, decisions, ACLs, and BC-local status.md
files remain authoritative. docs/hgate-project.json is one global, derived
projection for tools such as the project viewer; it is not a place to make or
approve decisions.
Non-Negotiable Rules
- Ask questions instead of silently filling gaps.
- Ask one focused question at a time.
- Label recommendations as recommendations, not decisions.
- Obtain explicit user confirmation for every material boundary or ownership conclusion.
- A gap remains
OPENuntil the user explicitly answers or confirms it. - Silence, topic changes, or acceptance of a neighboring point do not close a gap.
- Do not equate a domain, bounded context, feature, module, service, database, or team without evidence.
- Do not create source code, migrations, APIs, or detailed BC specification files.
- Do not force a multi-BC design when one cohesive model is sufficient.
- Do not force a single BC merely because the requirement was described as one feature.
- If evidence and the user's preference conflict, explain the risk and ask for a deliberate decision.
- Keep unresolved uncertainty visible in the final report.
Discovery Status Vocabulary
Use these statuses throughout the discussion:
| Status | Meaning |
|---|---|
OBSERVED |
Supported by user testimony or inspected evidence |
PROPOSED |
Recommended interpretation awaiting confirmation |
CONFIRMED |
Explicitly accepted by the user |
OPEN |
Missing, ambiguous, disputed, or unanswered |
DEFERRED |
Intentionally postponed with a reason and owner |
OUT_OF_SCOPE |
Explicitly excluded from this exploration |
Only the user can move a material conclusion from PROPOSED to CONFIRMED.
Gap Register
Maintain a visible register throughout the exploration:
| ID | Topic | Gap or question | Status | Resolution/evidence |
|----|-------|-----------------|--------|---------------------|
| G1 | Actor | Who approves a refund? | OPEN | |
| G2 | State | Can a rejected request be resubmitted? | CONFIRMED | Yes, as a new request |
Rules:
- Add a gap whenever behavior, terminology, ownership, lifecycle, or scope is ambiguous.
- Ask the highest-impact open question first.
- Record the user's answer before moving to the next question.
- If an answer creates another ambiguity, add a new gap.
- Do not mark a gap resolved based only on an AI recommendation.
- If the user cannot answer, keep it
OPENor explicitly mark itDEFERRED.
Workflow
Phase 0 - Establish the Exploration Scope
Before analyzing boundaries:
- Restate the problem in plain business language.
- Identify what triggered the exploration.
- Record the desired business outcome.
- Record known constraints and non-goals.
- List available evidence.
- Ask the user to correct or confirm the framing.
Use:
Exploration scope
Problem:
[Plain-language statement]
Desired outcome:
[Observable business outcome]
Known scope:
- [...]
Known non-goals:
- [...]
Open framing gaps:
- [...]
Is this an accurate starting point?
Do not begin bounded-context identification until the user confirms the problem framing.
Phase 1 - Business Discovery Interview
Ask the user to describe the requirement as a business process, without asking them to design the software.
Explore one topic at a time:
- Actors - who initiates, participates in, approves, or observes the process?
- Trigger - what causes the process to begin?
- Outcome - what business result must be produced?
- Decisions - which rules or policies change the outcome?
- State - what information changes over time?
- Lifecycle - what stages and transitions exist?
- Exceptions - what can fail, be rejected, be cancelled, or require recovery?
- Ownership - who owns each decision and source of truth?
- Timing - what must happen immediately, eventually, periodically, or manually?
- Constraints - what legal, commercial, operational, or technical limits apply?
Prefer questions such as:
- "What business event starts this process?"
- "Who is allowed to make that decision?"
- "What must remain true after this step completes?"
- "Does this term mean the same thing to every actor?"
- "What happens when this dependency accepts the request but the result is not received?"
Avoid prematurely technical questions such as:
- "Should this be a microservice?"
- "Which database table should own this?"
- "Should this use REST or events?"
Phase 2 - Build the Ubiquitous Language
Create a glossary from the user's language:
| Term | Business meaning | Used by | Ambiguities/anti-terms | Status |
|------|------------------|---------|------------------------|--------|
Look for:
- The same term with different meanings
- Different terms describing the same concept
- Technical words masking a business concept
- Verbs that imply business capabilities
- Nouns that may represent entities, value objects, policies, or events
When conflicting meanings appear, do not normalize them silently. Ask whether they represent different perspectives or different bounded contexts.
Phase 3 - Identify Business Capabilities
Group confirmed behavior into capabilities. For each capability record:
Capability:
Business purpose:
Primary actors:
Trigger:
Outcome:
Rules and decisions:
State owned:
Reason to change:
Dependencies:
Status:
Capabilities describe what the business must be able to do. They are not yet bounded contexts.
Ask the user to confirm that:
- No essential capability is missing
- No listed capability is merely an implementation detail
- Each capability has a distinct business outcome
Phase 4 - Form Bounded Context Hypotheses
Use the capabilities and language to propose one or more bounded contexts.
Signals that capabilities may belong to one BC
- They share one cohesive business purpose
- They use the same language with the same meanings
- They operate on the same closely related model and lifecycle
- They enforce rules that must remain consistent together
- They have the same business owner and reason to change
- Separating them would create artificial coordination without clarifying ownership
Signals that multiple BCs may be needed
- The same term has different meanings in different workflows
- Capabilities have independent business purposes or lifecycles
- Different actors or owners make independent decisions
- Different policies cause them to change independently
- They maintain different sources of truth
- They can succeed, fail, or evolve independently
- Integration is naturally expressed as a contract, domain event, or policy boundary
- Combining them would require one model to serve conflicting meanings
Treat these as diagnostic signals, not automatic rules.
For each proposed BC present:
Proposed BC: [name]
Purpose:
Owns:
Does not own:
Ubiquitous language:
Key capabilities:
Primary actors:
Source of truth:
Reason to change:
Adjacent BCs:
Evidence:
Remaining gaps:
Status: PROPOSED
Then ask the user to confirm, reject, or modify the proposal.
Phase 5 - Test the Boundaries
Walk representative scenarios across the proposed map:
- A normal successful journey
- A meaningful rejection or failure
- A changed or cancelled journey
- A scenario involving concurrent or repeated actions
- A scenario crossing every proposed BC boundary
For each step ask:
- Which BC makes the business decision?
- Which BC owns the resulting state?
- Is another BC informed, or must it synchronously request a decision?
- Does the receiving BC translate the concept into its own language?
- Could either side change independently without sharing internal models?
If a scenario cannot be assigned cleanly, reopen the relevant boundary gap.
Phase 6 - Classify the Subdomains
After the boundaries are confirmed, recommend a classification:
| Classification | Use when |
|---|---|
| Core Domain | Provides strategic differentiation or unique business advantage |
| Supporting Subdomain | Necessary for the business but not a primary differentiator |
| Generic Subdomain | A broadly solved capability that should usually be bought, reused, or minimally customized |
For each BC provide the recommendation and rationale, then ask for explicit confirmation. Classification is a strategic business decision, not a measure of technical complexity.
Phase 7 - Describe Context Relationships
For each relationship identify only what is needed for the discovery handoff:
Provider/owner:
Consumer:
Business information or decision exchanged:
Source of truth:
Consistency expectation:
Candidate interaction: request/response | domain event | scheduled sync | TBD
Translation or ACL needed: yes | no | TBD
Open contract questions:
Status:
Do not design detailed port interfaces, DTOs, endpoints, topics, or schemas here.
Those belong in the affected BC's bc-refinement session.
For a cross-BC feature:
- Identify every affected BC.
- Identify the owner of each business decision and state transition.
- Record the agreed information exchanged between contexts.
- Recommend one separate
bc-refinementorbc-enhancementfork per BC. - Carry the confirmed relationship as a handoff into each fork.
Phase 8 - Gap Closure Review
Before concluding, show all gaps grouped by status:
OPENDEFERREDCONFIRMEDOUT_OF_SCOPE
For every OPEN gap ask whether the user wants to:
- Resolve it now
- Defer it with an owner and reason
- Declare it out of scope
Ask one gap at a time. Do not batch approvals.
If an open gap could materially change a BC boundary, ownership decision, or Core/Supporting/Generic classification, the exploration cannot be called final. Mark the affected conclusion as provisional.
Phase 9 - Final Confirmation Gate
Present the complete proposed Domain Exploration Report and ask the user to confirm it.
The report must include:
# Domain Exploration Report
## Problem and desired outcome
## Scope and non-goals
## Confirmed ubiquitous language
## Business capabilities
## Domain and bounded context map
## Single-BC or multi-BC conclusion
## Subdomain classifications
## Context relationships
## Confirmed decisions
## Open and deferred gaps
## Recommended next hGATE sessions
Do not describe the report as final until the user explicitly confirms it.
Phase 10 - Handoff
After confirmation, recommend the next skill:
- Use
bc-refinementonce per newly identified or not-yet-specified BC. - Use
bc-enhancementonce per already-built BC affected by a changed requirement. - Use
bc-reviewwhen the user wants to audit an existing BC specification or compare it with implementation. - Use
architecture-decision-explorationwhen a technical or cross-system architecture decision remains ambiguous after business boundaries are known.
Every BC handoff should include:
- Confirmed BC purpose and classification
- In-scope and out-of-scope capabilities
- Ubiquitous language
- Owned decisions and state
- Adjacent BC relationships
- Relevant open or deferred gaps
Persist the confirmed domain and context maps before closing the session. Create
or update each confirmed BC's local status.md and record the transition to
DISCOVERED. The domain map must link to local status files instead of
duplicating mutable lifecycle state.
Then synchronize docs/hgate-project.json because confirmed boundaries,
relationships, journeys, and lifecycle values changed. Project schema version 1
contains project, domains, boundedContexts, relationships, and
journeys. Use stable IDs from the maps, read lifecycle only from each BC's
status.md, include source artifact paths, omit timestamps, and sort every
collection deterministically by stable ID (and nested ports/ACLs by name).
Validate the result against docs/hgate-project.schema.json. Do not complete
the handoff if the projection is stale or invalid.
Recommendation Protocol
When the AI has a preferred interpretation:
- State the recommendation.
- Explain the business evidence and tradeoff.
- Name credible alternatives.
- State which gaps remain.
- Ask the user to confirm, reject, or adjust it.
Use:
Recommendation: [...]
Why:
- [...]
Alternative:
- [...]
This remains PROPOSED because:
- [...]
Do you confirm this recommendation?
Never turn a recommendation into a confirmed decision without the user's explicit response.
Relationship to Other Skills
| Skill | Responsibility |
|---|---|
domain-exploration |
Understand the problem and identify domain/BC boundaries |
architecture-decision-exploration |
Resolve ambiguous technical and cross-system architecture decisions |
bc-refinement |
Produce detailed specification artifacts for one BC |
bc-review |
Audit one BC's specifications and implementation |
bc-enhancement |
Update specifications, code, and tests for an already-built BC |
cross-bc-validation |
Validate one completed journey across several implemented BCs without implementing fixes |
Completion Criteria
Domain exploration is complete only when:
- The problem and desired outcome are confirmed
- The important business capabilities are confirmed
- Material terminology conflicts are resolved or explicitly deferred
- The single-BC or multi-BC conclusion is confirmed
- Every proposed BC has confirmed ownership and exclusions
- Every BC classification is confirmed
- Cross-BC relationships identify the source of truth
- No boundary-changing gap is silently treated as resolved
- Remaining open items are visible and assigned a disposition
- The user explicitly confirms the final report
- Confirmed maps are persisted when repository access is available
- Every confirmed BC has a local lifecycle status artifact
- Stable IDs exist for every projected BC, relationship, and journey
docs/hgate-project.jsonmatches the authoritative artifacts, has deterministic ordering and no timestamps, and passes schema validation
If these conditions are not met, produce an interim report and clearly label the affected boundaries as provisional.
04 同仓库更多 Skills
cart
暂无简介
ordering
暂无简介
catalog
暂无简介
hgate-guide
Use this skill when a user needs help deciding where to start or which hGATE skill to use next. It diagnoses the current lifecycle stage, checks available artifacts, recommends exactly one next skill, and explains that skill's input, output, fork requirement, and completion signal. Trigger phrases include "how do I use hGATE", "what should I do next", "which skill should I use", "where do I start", and "guide me through the workflow". It never invokes another skill or advances lifecycle state automatically.
cross-bc-validation
Use this skill to validate one completed business journey that crosses two or more implemented bounded contexts. It performs a read-only comparison of published contracts, events, ports, adapters, runtime wiring, and tests; identifies incompatible or missing journey hops; and routes each finding to its owning BC. Trigger phrases include "validate this cross-BC feature", "verify the end-to-end bounded context flow", "check integration between these BCs", and "does this business journey work across contexts". It does not redesign boundaries or implement fixes.
bc-review
Use this skill to review, audit, or assess a Bounded Context in two phases: first inspect its skill/specification files for failure paths, boundaries, ambiguity, contradictions, authorization, tenant isolation, concurrency, external failures, observability, and audit requirements; then verify every finding against implementation code and tests. Trigger phrases: BC review, bounded context review, review skill files, specification audit, check findings in code, documentation versus implementation, gap analysis.