wtf.steer-design
Steer Design
Generate or refine docs/steering/DESIGN.md — the design guidelines document. This document is the canonical reference for design decisions, the system in use, tokens, patterns, and accessibility requirements that every designer and implementer must follow.
The shared steering-doc flow (exists-check → research → interview → draft → review → write → wiki sync → continue) lives in ../references/steering-doc-process.md. Follow that process with the skill-specific inputs below.
- Doc path:
docs/steering/DESIGN.md - Template:
references/design-template.md - Display name / wiki page:
WTF-Design.md - Commit message:
docs: add design guidelines steering document
Step 2 — Research checklist
Use the Agent tool to extract design facts directly. Do not ask the user for things that can be read:
- Design system: Storybook config, component library imports, design-system packages in
package.json - Tokens: CSS custom properties (
--color-*,--spacing-*), Tailwind config, theme files, token definition files - Components: existing UI components (look for
components/,ui/,src/components/) - Figma links: any Figma URLs in README, existing issues, or
docs/ - Accessibility: existing WCAG references, axe configs, jest-axe usage
- Responsive breakpoints: Tailwind config, CSS media queries, layout files
docs/steering/VISION.mdif it exists — extract any design principles already stated there
Produce a draft of Stack, Tokens, and Component Patterns from research alone where possible.
Step 3 — Gap-topic list
Apply ../references/questioning-style.md for questions in this step. Ask only about items research could not determine:
- Design principles — "What 3–5 principles guide every design decision for this product?" Pre-fill from
VISION.mdor any existing design docs. - Design system — "What design system are you using? Do you have a Figma library?" Pre-fill with anything found in the codebase or imports.
- Token gaps — "Are there tokens not yet defined in code that designers rely on?" Pre-fill with gaps inferred from design-system research.
- Responsive strategy — "How does the layout adapt across breakpoints?" Pre-fill with breakpoints found in the codebase.
- Accessibility target — "Are there accessibility requirements beyond WCAG 2.1 AA?" Pre-fill with any existing a11y config found.
Step 4 — Writing rules
- Tokens must reflect what is actually defined in the codebase — not aspirational values.
- Component patterns reference real component paths where they exist.
- Accessibility section always includes the baseline rules from the project's
CLAUDE.md(if present) plus any additions. - Principles are written as design directives, not engineering constraints.
Step 8 — Continue options
{label: "Create QA.md", description: "Run wtf.steer-qa to document the QA standards"}{label: "Create TECH.md", description: "Run wtf.steer-tech to document the technical guidelines"}{label: "Create VISION.md", description: "Run wtf.steer-vision to document the product vision"}{label: "Stop here", description: "Exit — no further action"}
More from xiduzo/wtf
wtf.write-feature
This skill should be used when a user wants to create a GitHub Feature issue, break down an Epic into user-facing capabilities, write user stories in domain language, or capture what a domain actor can do — for example "create a feature", "write a feature for this epic", "add a feature to an epic", "break this epic into features", "write user stories for this feature", or "describe what this actor can do". Use this skill to write a single Feature; use `wtf.epic-to-features` to generate the full set of Features for an Epic at once. Not applicable to Tasks, Epics, or bug reports.
38wtf.write-task
This skill should be used when a user wants to create a task, write a ticket, decompose a feature into implementable work, break down a story, define a vertical slice for development, or write Gherkin scenarios — for example "create a task", "write a task for this feature", "break this feature into tasks", "define implementation work", or "add a sub-issue to this feature". Guides creation of a GitHub Task issue linked to a parent Feature and Epic, derives Gherkin acceptance scenarios from the Feature's ACs, enforces DDD ubiquitous language in scenarios, and checks for vertical-slice integrity and task dependencies.
38wtf.write-epic
This skill should be used when a user wants to create, draft, or plan a GitHub Epic issue — for example "write an epic", "I want to define a new initiative", "scope out this strategic project", "turn this idea into an epic", "plan work that spans multiple features", or "start from a bounded context". Also use when the user asks to define domain outcomes, capture a large initiative before breaking it into features, or describe work in terms of business goals rather than technical tasks.
38wtf.reflect
This skill should be used when a developer wants to capture learnings from a difficult session, record what Claude got wrong, save implementation gotchas, or update the steering docs with hard-won knowledge — for example "let's reflect", "capture what we learned", "that was painful, save this", "update the steering docs with what went wrong", "I need to debrief", "what went wrong today", "log this lesson", "save this gotcha", "document this mistake", "I want to write this down before I forget", "add this to the steering docs", or when prompted by the intervention tracker after multiple corrections. Routes each learning into the right steering doc (TECH, QA, DESIGN, or VISION) under a "Hard-Won Lessons" section.
37wtf.verify-task
This skill should be used when a QA engineer wants to test or verify a completed task, run through acceptance criteria, check Gherkin scenarios against the implementation, record pass/fail results, or sign off on a ticket before merge. Triggers on phrases like "verify task #42", "run QA on this issue", "test the acceptance criteria", "sign off on task", "check if this task is ready to merge", "does this task meet its acceptance criteria", "run acceptance tests for task #X", "walk through the Gherkin for task #X", or "I want to test this task".
37wtf.report-bug
This skill should be used when a developer or QA engineer wants to report a bug, create a bug ticket, document a test failure, log a defect, file an issue found during a QA session, or report something that is broken — for example "report a bug", "create a bug ticket", "I found a defect", "something is broken in task #X", or "document this test failure". Files a structured GitHub Bug issue that links the originating Task and Feature, maps failing Gherkin scenarios as reproducible test evidence, and fills every section of the BUG template.
37