design
Resolve design decisions (types, contracts, package topology, module boundaries) in discussion rounds before /planning:plan, as design artifacts. Use when: 'design this', 'type modeling', 'figure out the abstractions', 'model this domain', 'what should the types look like', 'how should I structure this', 'where do the module boundaries go', or entering /planning:plan without exploring the design space. Skip when scanning existing code for module friction: /architecture:improve does that, and /planning:design resolves decisions before /planning:plan. Handoff gate: /planning:design-handoff.
- License 许可
- MIT
- 最近更新
- 2026-11-15
- Stars
- ★ 30
- Forks
- 7
01 前言 Front Matter
- metadata
- { "summary": "Resolve types, contracts, and module boundaries before planning", "workflow-stage": "design" }
- description
- Resolve design decisions (types, contracts, package topology, module boundaries) in discussion rounds before /planning:plan, as design artifacts. Use when: 'design this', 'type modeling', 'figure out the abstractions', 'model this domain', 'what should the types look like', 'how should I structure this', 'where do the module boundaries go', or entering /planning:plan without exploring the design space. Skip when scanning existing code for module friction: /architecture:improve does that, and /planning:design resolves decisions before /planning:plan. Handoff gate: /planning:design-handoff.
- argument-hint
- [library|module|data|integration|system] [status|thread <name>|discuss|terminology|handoff]
- user-invocable
- true
- disable-model-invocation
- false
02 资源文件 6
- 参考文档evals/evals.json22.5 KB
- 参考文档reference/design-defaults.md5.8 KB
- 参考文档reference/reversibility.md5.1 KB
- 参考文档reference/type-discipline.md3.6 KB
- 参考文档reference/type-discipline/typescript.md7.5 KB
- 参考文档templates/design-view.html7.2 KB
03 SKILL.md 正文
Arguments. [library|module|data|integration|system] [status|thread <name>|discuss|terminology|handoff].
e.g., /planning:design library, /planning:design module, /planning:design status, /planning:design discuss,
/planning:design handoff
Repository context. Gather first
Collect these with individual Bash calls, one command per call, never combined:
- Current branch,
git branch --show-current
Treat a failure (not a repository, git unavailable) as an unknown value and carry on. Keep these as body Bash calls, not pre-compute lines. How the harness runs a skill's injected commands: How injected commands run.
Variables
Arguments: $ARGUMENTS
Purpose
Design answers WHAT before /planning:plan answers HOW: types, boundaries and package topology the
user has validated through discussion. Exploration maps existing code, research gathers external
facts, this skill turns both into a design. When the PROBLEM is still rough and no approach is
chosen, diverge first via /planning:brainstorm (cheapest→most-ambitious candidates, user
reacts), then design the direction that resonated.
Level this skill decides: interfaces and contracts, the types, boundaries and module shapes
other code depends on; behavior is the interview's Brief, and files and symbols are
/planning:plan's.
Depth scales to the work:
- Single-file fix → early-exit: write
design-resolution.mdwithoutcome: early-exit, tierC, and reason. Then invoke/planning:design-handoffvia the Skill tool, which writes PLAN.md's one-line## Designrecord and hands off to/planning:plan - New module → light-form (1-2 discussion rounds, basic type sketch)
- Large library or system → full-form (multiple sessions, all phases, all artifact types)
The stage always runs; early-exit is a valid outcome. Gate artifact: Tier C and light Tier B
early-exits MUST produce design-resolution.md in the topic's design slice
(<memory_dir>/<topic-slug>/design/, default .work/) so /planning:plan's prerequisite check
can verify the gate without conversation memory.
design-resolution.md (early-exit artifact)
---
outcome: early-exit
tier: C
reason: <one line, e.g. single-file bugfix, docs-only>
---
Tier B (required): the type sketch, inline or as a link to type-inventory.md.
/planning:design-handoff quotes it into PLAN.md's `### Contracts`.
Gates
These hold after a compaction re-attach. Later sections say how to carry them out.
- Collaborative always. Never autonomously decide design. Ask in frontier rounds (Key behaviors).
- Abstract is never the agent's pick. A variation-point verdict of abstract comes only from the
user: interactively ask, recommending contain; unattended, apply contain and record the question
as a human decision. Full rule:
${CLAUDE_PLUGIN_ROOT}/reference/variation-points.md"Autonomy". - Every recommendation carries a
Basis:line:verifiedwith thefile:line, tool output, or URL it rests on, orjudgment(non-consequential only). A consequential one (cross-repo, shared infrastructure, irreversible, or security) is grounded before it is presented; one research cannot settle is withheld, recorded as adeferredthread whose research tag names the evidence that would settle it.
Action Router
Parse $ARGUMENTS for scope and action:
| Argument | Action |
|---|---|
| (empty) | Auto-detect. Read the PLAN.md Brief + conversation to determine scope and phase. Resume if design artifacts exist. Ask if ambiguous |
library |
Library/API design. Packages, types, contracts, dependency graph |
module |
Module design. Domain model, boundaries, contracts. Suggest a domain-event workshop (e.g. EventStorming) when the environment provides one |
data |
Data model design. Entities, relationships, schema decisions |
integration |
Integration design. Cross-system contracts, sequence flows, error handling |
system |
System design. Components, communication patterns, deployment topology |
status |
Status report. Resolution state per thread and question |
thread <name> |
Deep-dive. One design thread |
discuss |
Discussion round. Systematic gap-finding across all artifacts |
terminology |
Naming review. Cross-cutting naming pass over the full type inventory (see "Terminology pass") |
handoff |
Handoff gate. Delegates to /planning:design-handoff (see "Handoff gate") |
Phases
Phases may interleave. Track which have produced artifacts and which have open questions.
All artifacts live in <memory_dir>/<topic-slug>/design/ (default .work/), never committed;
/planning:plan's gate reads the gate files (design-threads.md, design-resolution.md) from
there. Placement:
${CLAUDE_PLUGIN_ROOT}/reference/artifact-protocol.md.
/planning:design-handoff writes the durable content (module layout, contracts, variation
verdicts, conventions followed) into PLAN.md's ## Design, the copy that reaches the plan, the
implementer's brief, and the pull request body or linked issue where PLAN.md is published. Derive
<topic-slug> from the task or branch name (kebab-case, ≤40 chars; shared with /planning:interview and /planning:plan). Skip
artifact creation for read-only actions (status).
Phase 1: Problem Space Decomposition
Read the Brief's ### Problem before decomposing; absent, start from the Problem, Intent (why, in the user's words) and Chosen direction lines of <memory_dir>/<topic-slug>/brainstorm.md's
## Handoff block when it exists; with neither, establish it:
${CLAUDE_PLUGIN_ROOT}/context/problem-framing.md. Its
time_units user layer is ${user_config.time_units} (unexpanded means unset).
Scan the whole problem space broadly before diving into any single capability. For each capability or concern:
- Domain concepts (nouns, verbs, relationships)
- Invariants (rules that must always hold)
- Storage needs (stateless? persistent? app-specific?)
- Cross-app reuse: shared-library-worthy vs app-specific, following the consuming project's library-organization and dependency-preference conventions when it declares them
When the work adds a requirement to existing code, ask before Phase 3: had this requirement been known when the code was first written, which types and boundaries would it have? Take that answer as the target shape, not the current shape with the requirement bolted on.
Produce: capability-matrix.md (library scope) or equivalent per scope.
Phase 2: Design Threads
Identify cross-cutting decisions that affect multiple capabilities. For each thread: name the decision, list concrete options with tradeoffs, and resolve through discussion or defer with rationale + research tag. Status: resolved (decision made), directional (direction agreed, details deferred), deferred (needs research).
Two-candidate step. Take it when the codebase has nothing to copy for the thread, more than one approach is workable, and the decision is hard to reverse (a public contract, a stored format, a boundary other modules will build on):
- Write the criteria the candidates will be judged by into the thread before drafting any candidate.
- Draft at least two candidates that differ in structure: who owns the state, where the module split falls, or what shape the contract takes. A renamed or reordered copy of the first is not a second candidate.
- Judge each against the written criteria, and record the rejected ones with the reason in
design-threads.md.
When the thread is about how a screen or interaction looks or feels, invoke
/prototype:explore-directions via the Skill tool when it is among the available skills. When the
candidates differ in logic or state (the rules, a state machine, a data model, an API surface) and
a run can settle the fork, invoke /prototype:pressure-test observe via the Skill tool when it is
among the available skills, because running each candidate on the same inputs shows which one
holds where arguing them only predicts it. The test: name the event sequence or record that the
criteria turn on; when nobody can yet say with confidence how each candidate handles it, a run
settles the fork (pstack's exhaust-the-design-space principle). Confirm the scope of the
throwaway with the user before either route. When neither route applies or its skill is
unavailable, run the three steps here, describing each candidate in prose.
Open these threads when their trigger holds:
- Shared-state: a type can be read and changed by more than one concurrent actor (threads, processes, overlapping requests, background jobs). Cover which actors write it, what a reader sees halfway through an update, and whether the type is confined to one owner, immutable, or guarded.
- Tenancy posture (early): SaaS or B2B org-scoped products. Single- vs multi-tenant, isolation model, shared vs tenant-scoped data catalog.
- Refactoring posture: exploration surfaces high coupling, large types, or multi-responsibility files (refactor or strangler scope). Characterization-test strategy, seam map, incremental extract order, change budget.
- Test-seam posture: any feature with a testable surface. Sketch where its tests will attach;
reuse an existing seam before adding one, put any new seam as high in the stack as it can go, and
aim for the fewest seams that cover the surface. The change→test-type mapping lives in
/testing:plan's classification table; cite it when thetestingplugin is enabled, otherwise apply standard test-design judgment. The sketch is input, not the decision:/planning:plan's Test strategy names the test boundaries from it and its Step 5 approval settles them; a seam the design needs as a contract still goes in Contracts.
Variation-point pass. Always for integration, module, and system; for library and
data, when the design touches an external system or a domain category. List every variation
point (every external integration is one), ask the two questions (likelihood of a second variant,
cost of change after shipping), and open one thread per point that resolves to a verdict: abstract
now, contain now and abstract later (the default for anything external), or leave inline (internal
one-offs only). Run the leak test on every abstraction and contained boundary, and place seams
where the solution's existing architecture style already puts them. Questions, verdicts, leak test,
autonomy rule, and sources:
${CLAUDE_PLUGIN_ROOT}/reference/variation-points.md.
A variation-intent answer from /planning:interview is settled, never re-asked.
Produce: design-threads.md
Phase 3: Type Modeling
The phase ends with a type-inventory.md in which every type traces to a call site that needs it,
and each type's shape is set by the operations its busiest paths run on it. Two checks prove it:
- Call sites before types. From consumer code, sketch two or three brief calls into the new contract, written as its users will write them, before any type has a name; for a library or API, at least one sits inside the importing package. A type enters the inventory only if those calls need it, given the capabilities.
- Operations set structure. Each entry lists its operations (lookup by key, ordered walk, append, bulk replace) with the busiest-path ones flagged, and its structure is the one those flagged operations favor.
Apply reference/type-discipline.md: Phase 3 meets each of its
situations while it fills type-inventory.md, so find the row that matches and make its decision.
Idioms for one language sit in that language's own file under reference/type-discipline/; open
one only after detecting the language:
| Language | File | Loaded when |
|---|---|---|
| TypeScript | reference/type-discipline/typescript.md |
the repository has a tsconfig.json, or the change touches .ts, .tsx, .mts or .cts files |
The inventory covers:
- Records, enums, strongly-typed IDs, value objects
- Contracts: interfaces with method signatures
- Read and follow the consuming project's naming conventions (interface naming, context-relative naming, collisions with common library types, namespaces) before naming
- Follow the project's codified design principles (e.g. Law of Demeter, dependency direction, disambiguating overloaded terms) where declared; otherwise low-coupling/high-cohesion defaults
- Invoke
/domain-driven-design:ubiquitous-language curatevia the Skill tool (if that plugin is enabled) the moment a domain term resolves, so the glossary owner applies the consumer's format, placement, and context routing; without it, record the resolved term and rejected synonyms in the design artifacts
Produce: type-inventory.md
Close Phase 3 by auditing the inventory: for each type, follow one value from where it is made to where it is read. A fault at any stop sends that type back to the design threads.
- Where it is made. When a schema, spec or migration already describes the shape, the entry derives from it instead of redrawing it. A value from outside the program becomes this type where it arrives, and nothing further in validates that input again.
- What it holds. Try to write a mix of field values the domain forbids; a type that accepts it is too loose. For each type the design strengthened, name the function that would fail on part of its input without the extra strength; with none, the strength guards nothing, and that is a fault too.
- Where it is read. Picture one more variant: every reading site must then fail to compile, not keep running silently. On the same path, every cast, assertion or suppression has a check in front of it.
Once type modeling stabilizes, run the terminology action over the whole inventory; per-type
naming during modeling does not replace it.
Phase 4: Package/Module Topology
- Package or module structure with dependency graph
- What goes where (abstractions vs implementation vs service defaults)
- Adapter surfaces (infrastructure boundary)
- Dependency direction enforcement per the project's declared layer rules
Produce: library-topology.md (library scope) or equivalent per scope.
When the dependency graph reads more clearly visually, optionally also emit a self-contained HTML
topology view to the OS temp directory, never beside library-topology.md, which stays the record.
Rules:
${CLAUDE_PLUGIN_ROOT}/reference/artifact-protocol.md.
Resolve medium first per
${CLAUDE_PLUGIN_ROOT}/reference/rendered-view.md
"Other optional views", with this plugin's medium option ${user_config.medium}, or "" when that
reads empty or unsubstituted (never put a ${user_config.*} string in a shell command), and follow
its result, which names the report line to print.
Phase 5: Discussion Rounds
Each round:
- Re-read all design artifacts.
- Record as design threads: underspecified types, missing contracts, boundary friction, pattern concerns, and design-default gaps (configurability, extension axes, observability, testability).
- Present findings ordered by tweak likelihood (the presentation default
/planning:planStep 5 documents): public contracts, data shapes, and user-facing surfaces lead; settled-looking mechanical threads sit at the bottom. Order only; thread dependencies still govern what can resolve when. - When discussion surfaces project-wide principles, suggest codifying them in the project's own rules.
Continue until no new gaps surface, then run the handoff action.
Lifecycle and reversibility
Skip on early-exit, status, or trivial single-file work. Otherwise call each significant decision
a one-way or two-way door, prompt an ADR for each one-way door, and scale investment by subdomain
and quality bar: reference/reversibility.md.
Terminology pass (terminology action)
Over the full type inventory, once type modeling stabilizes:
- Check interface-naming form and context-relative naming against the project's conventions
- Check collisions with common library/framework type names (e.g. a bare
Result<T>when the stack already ships one) - Check overloaded-term disambiguation and domain accuracy against the project's domain vocabulary
- Record decisions in a terminology table inside
type-inventory.md - Invoke
/domain-driven-design:ubiquitous-language curatevia the Skill tool (if enabled) to sync resolved terms and rejected synonyms into the project's glossary; the table above is the standalone fallback
Handoff gate (handoff action)
Invoke /planning:design-handoff via the Skill tool. It is the only gate implementation: it checks
design-threads.md (or the design-resolution.md early-exit artifact) and on PASS emits the
plan-ready summary and resume prompt. This skill carries no gate criteria of its own; criteria changes land in
/planning:design-handoff only.
On PASS, offer an interactive design view of PLAN.md's ## Design (its sections, a tick for each one
the reader questions, a copy-out of the reply, sent to this session when connected). PLAN.md stays the
record. Build it only with ${CLAUDE_PLUGIN_ROOT}/scripts/build-view.mjs from that record, never
hand-written; it runs the shared medium resolver and publish gate with this plugin's medium option
${user_config.medium}, or "" when that reads empty or unsubstituted (never put a
${user_config.*} string in a shell command), and you print the report line it prints. Procedure:
${CLAUDE_PLUGIN_ROOT}/reference/rendered-view.md.
Stub files (scaffold_stubs). Before invoking the gate, resolve scaffold_stubs, lowest layer
first: the default false; the plugin's user config (${user_config.scaffold_stubs}, where a
literal unexpanded value means unset); then the scaffold_stubs key of the repository's
docs/conventions/planning.yaml, which wins when set, read only when the working directory's git
root is neither $HOME nor an ancestor of it. Only the bare booleans true and false are valid:
any other value, a quoted "true" included, is named with its file (or user config), key and
value, and that layer is dropped, so a valid higher layer still wins and otherwise the key is
false. Report one line naming the value and its layer, e.g.
scaffold_stubs: true (docs/conventions/planning.yaml). Keys and layers:
${CLAUDE_PLUGIN_ROOT}/reference/config.md.
With true, add a ## Stub scaffold section to design-threads.md (or to design-resolution.md
on an early exit) listing every new file the design introduces, each with the signatures it will
declare (types, function and method signatures, exported constants), from the resolved type
inventory and contracts. Each stub body is the language's ordinary not-implemented form (for
example raise NotImplementedError in Python or todo!() in Rust), with no per-language reference
file. After the gate passes, the handoff output names those files and signatures so
/planning:plan can place the stub phase. With false, write no such section and name no stubs.
Scope-specific artifacts
| Scope | Primary artifacts | Typed artifact | Dialect |
|---|---|---|---|
library |
capability-matrix.md, type-inventory.md, library-topology.md, design-threads.md | none | none (no typed artifact, so no scope label) |
module |
domain-model.md, module-boundary.md, contracts.md, design-threads.md | none | none (no typed artifact, so no scope label) |
data |
entity-relationships.md, schema-decisions.md, design-threads.md | entity-relationships.md |
mermaid erDiagram by default; DBML when diagram_dialect.data resolves to dbml |
integration |
contract-spec.md, sequence-flows.md, design-threads.md | sequence-flows.md, contract-spec.md |
mermaid sequenceDiagram for the flows; an OpenAPI 3.1 sketch for the contract spec |
system |
component-map.md, communication-patterns.md, design-threads.md | component-map.md, and only when diagram_dialect.system names a dialect |
a C4 container view in LikeC4 or C4-PlantUML, never Mermaid's C4 diagrams |
design-threads.md is common across all scopes.
Typed artifacts: dialect and scope label
Typing adds a declared dialect and a scope label to artifacts this skill already emits; no new
file. Everything the Typed artifact column does not name (schema-decisions.md,
communication-patterns.md, every library and module artifact) stays prose with no dialect and
no scope label. component-map.md is likewise untyped prose with no scope label whenever
diagram_dialect.system is unset, so a downstream lookup finds nothing rather than an unlabeled
diagram.
The scope label. Every typed artifact opens with frontmatter naming the producing scope and the dialect of its fenced block:
---
scope: data
dialect: mermaid
---
scope is one of data, integration, system. dialect is one of mermaid, dbml,
openapi-3.1, likec4, c4-plantuml. /work-items:decompose (when the work-items plugin is
enabled) reads the label to inline the artifact under a provenance note naming scope and dialect;
without that plugin the label is inert. The body is one fenced block in the declared dialect,
followed by the artifact's prose. Tag the fence with the renderer name: mermaid, dbml, yaml
for the OpenAPI 3.1 sketch, likec4, plantuml. An integration session labels two artifacts,
one per typed file.
Resolving the dialect. diagram_dialect is a team-shared convention key split by artifact kind
(diagram_dialect.data, diagram_dialect.system). Resolve it per session, before writing a typed
artifact, through
${CLAUDE_PLUGIN_ROOT}/context/authoring-formats.md
"Resolution ladder", where <plugin-root> is ${CLAUDE_PLUGIN_ROOT} and <project-root> is ${CLAUDE_PROJECT_DIR} (unexpanded or empty means unset). This skill takes no dialect argument, so the argument layer is always empty.
diagram_dialect.data defaults to mermaid, and every degrade writes the data artifact in
mermaid. diagram_dialect.system has NO default: unset or degraded, emit no C4 container view
and behave exactly as with no convention doc at all, reporting its provenance as
unset (no C4 view emitted).
Diagram craft. For mermaid layout, readability, and syntax idiom, invoke
/visualization:visualize via the Skill tool (if the visualization plugin is enabled). Without
it, emit the plainest correct form of the dialect. The typed artifact is produced either way.
Key behaviors
- Frontier rounds. Every open thread whose prerequisites are settled surfaces in the same
numbered round, each with a recommendation; a thread that depends on an unresolved thread waits
for the round after it resolves. Render a round via
AskUserQuestiononly when the plugin'suse_ask_user_questionuser config (${user_config.use_ask_user_question}; unexpanded or empty means off) is on and the round is independent questions that fit oneAskUserQuestioncall (the per-call question limit: https://code.claude.com/docs/en/agent-sdk/user-input#limitations). Inline prose otherwise - Grounding steps. Ground a consequential recommendation in the affected code plus its
consumers and in external research that reads official docs first, routed to
/discovery:exploreand/discovery:researchif enabled. A recommendation that changes is restated as old → new → why. Contract:${CLAUDE_PLUGIN_ROOT}/context/recommendation-basis.md - Self-answer before asking. Each candidate question first passes
${CLAUDE_PLUGIN_ROOT}/context/self-answer.md: a fact it settles is stated with its basis and source tag, not asked - Track resolution status. Every question and thread is resolved / directional / deferred. Deferred items carry a research tag naming the external investigation needed
- Codify rules when discovered. When discussion surfaces a project-wide principle, suggest codifying it immediately in the project's own rules files
- Incremental artifacts. Build artifacts as discussion progresses and update them as decisions
evolve. Re-read multi-turn shared artifacts (
design-threads.mdand peers) from disk before every write, since another turn or agent may have changed them, and prefer appending or refining over wholesale rewrites - Dependency order awareness. Surface which decisions block others so
/planning:plancan sequence phases - Resume from prior state. When design artifacts exist in the topic's design directory, read them, summarize current state, and identify remaining gaps
- Suggest adjacent skills. When a domain-event workshop fits better for domain modeling,
suggest it if available. Suggest
/discovery:research(if enabled) for a deferred item needing external research, and theterminologythenhandoffactions at the session tail - Design defaults (non-trivial scopes only). For
library,module,data,integration, andsystemscopes, when discussion touches configurability, extension points, observability, or testability, open a design thread for it. Extension points start from the Phase 2 variation-point pass. Skip on early-exit,status, or trivial single-file work. Applyreference/design-defaults.mdfirst (quality bar, consumer standards, the Brief's quality requirements, generalize-now-or-wait, per-tenant configurability as vendor guidance), then recommend from every principledesign-principles.mdlists.
What this skill does NOT do
- Implementation planning:
/planning:plan(phases, sanity checks, file-level work items) - Code writing: the implementation stage
- External research: the research capability; this skill synthesizes its results
- Diagram craft: this skill selects the dialect; layout and idiom route to
/visualization:visualizeif enabled, else the plainest correct form is emitted - UI/UX design: user research, flows and information architecture are
/user-experience:shape(if enabled); look and response are/user-interface:design(if enabled) - Domain event workshops: an EventStorming-style capability; this skill may suggest it within module design
- Product intent:
/planning:prd(problem, users, success metrics) - Intent contract:
/planning:interview(goal, constraints, acceptance criteria)
Next
- Design finished, to gate and write into PLAN.md's
## Design, which /planning:plan reads: /planning:design-handoff. - The contract is a UI component's props API (parts, variants, controlled state): /user-interface:design.
Relationship to other skills
| Skill | Relationship |
|---|---|
/planning:interview |
Before. Locks the brief (scope + constraints); design explores the solution space within them |
/domain-driven-design:ubiquitous-language curate |
During. Owns project-glossary updates when design resolves domain language; not type or boundary design |
/visualization:visualize (if enabled) |
During. Owns visual-form choice and mermaid craft for a typed artifact's fenced block |
/naming:name-it-better (if enabled) |
During. Proposes candidates for a name the design leaves undecided; the human picks, and the pick is recorded in the terminology table |
/architecture:record-decision (if enabled) |
During. Records the ADR for a one-way door when its thread resolves (reference/reversibility.md) |
/work-items:decompose (if enabled) |
After. Reads a typed artifact's scope and dialect label to inline it into the spec container with a provenance note, and quotes each slice's part of PLAN.md's ## Design into that slice's body |
/discovery:explore (if enabled) |
Before. Maps existing code; design creates what SHOULD exist |
/discovery:research (if enabled) |
Before + parallel. Gathers external facts; deferred research items can run in parallel |
/planning:design-handoff |
The gate. Owns the design→plan gate criteria and the plan-ready summary |
/planning:plan |
After the handoff gate. Produces HOW; when design artifacts exist it consumes them instead of re-deriving design |
04 同仓库更多 Skills
track
Backlog reads through the bound tracker: search open and closed items, view one item with its comments and state history. Use when another skill searches or reads tracker items.
reviewer-media
Reviewer media for one pull request: decides whether it needs a narrated walkthrough, builds the storyboard from /review:explain-change's digest, has /explainer-video:produce render it and hands the manifest to /source-control:pull-request media. Use when asked for 'reviewer media', 'a walkthrough video for this PR', 'a produced video of this change', or when pull-request ready or monitor hands a PR over.
route
Model and effort per agent role (orchestrator, worker, verifier, retrieval) for a multi-agent run, resolved through the bundled defaults and the user, team and personal override config layers into fenced JSON with single-agent and fan-out variants and the layer behind each value. Use when asked 'which model for the subagents', 'route the roles' or 'model routing', or before a skill passes a role's model on a spawn.
route
Model and effort per agent role (orchestrator, worker, verifier, retrieval) for a multi-agent run, resolved through the bundled defaults and the user, team and personal override config layers into fenced JSON with single-agent and fan-out variants and the layer behind each value. Use when asked 'which model for the subagents', 'route the roles' or 'model routing', or before a skill passes a role's model on a spawn.
principles
Module-design vocabulary for architecture findings, and the checks built on it. Use when: 'what is a deep module', 'what is a seam', 'deep vs shallow module', 'what is the deletion test', 'leverage and locality', 'module design vocabulary', 'which word do we use for X in architecture findings'. Scanning a codebase for friction is /architecture:improve.
write
Structured five-field bug report (title, steps to reproduce, expected vs actual, justified severity, suggested fix location) from an informal description, read-only. Use when the user names a defect they observed, or asks for one written up ('report a bug', 'file a bug', 'write this up as a bug').