kiro-spec-design

kiro-spec-design Skill

Core Mission

• Success Criteria:
  • All requirements mapped to technical components with clear interfaces
  • The design makes responsibility boundaries explicit enough to guide task generation and review
  • Appropriate architecture discovery and research completed
  • Design aligns with steering context and existing patterns
  • Visual diagrams included for complex architectures

Execution Steps

Step 1: Gather Context

Reuse steering/spec context already available from conversation; load missing context below. Select skills for the current task even when steering/spec context is already available:

• {{KIRO_DIR}}/specs/{feature}/spec.json, requirements.md, design.md (if exists)
• {{KIRO_DIR}}/specs/{feature}/research.md (if exists, contains gap analysis from /kiro-validate-gap)
• Core steering context: product.md, tech.md, structure.md
• Additional steering files only when directly relevant to requirement coverage, architecture boundaries, integrations, runtime prerequisites, security/performance constraints, or team conventions that affect implementation readiness
• Use explicitly requested skills and task-relevant local skills/playbooks, including design, accessibility, and UX. Select by description and read only needed guidance, even for small tasks; preserve required checks and host/project rules.
• Consult relevant domain skills even when building by hand without adopting a new library.
• {{KIRO_DIR}}/settings/templates/specs/design.md for document structure
• Read rules/design-principles.md from this skill's directory for design principles
• {{KIRO_DIR}}/settings/templates/specs/research.md for discovery log structure

Validate requirements approval:

• If auto-approve flag is true: Auto-approve requirements in spec.json
• Otherwise: Verify approval status (stop if unapproved, see Safety & Fallback)

Step 2: Discovery & Analysis

Critical: This phase ensures design is based on complete, accurate information.

1. Classify Feature Type:

   • New Feature (greenfield) → Full discovery required
   • Extension (existing system) → Integration-focused discovery
   • Simple Addition (CRUD/UI) → Minimal or no discovery
   • Complex Integration → Comprehensive analysis required

2. Execute Appropriate Discovery Process:

   For Complex/New Features:

   • Read and execute rules/design-discovery-full.md from this skill's directory
   • Conduct thorough research using WebSearch/WebFetch:
     • Latest architectural patterns and best practices
     • External dependency verification (APIs, libraries, versions, compatibility)
     • Official documentation, migration guides, known issues
     • Performance benchmarks and security considerations

   For Extensions:

   • Read and execute rules/design-discovery-light.md from this skill's directory
   • Focus on integration points, existing patterns, compatibility
   • Use Grep to analyze existing codebase patterns

   For Simple Additions:

   • Skip formal discovery, quick pattern check only

Parallel Research (subagent dispatch)

The following research areas are independent and can be dispatched as subagents via the Agent tool. The agent should decide the optimal decomposition based on feature complexity — split, merge, add, or skip subagents as needed. Each subagent returns a findings summary (not raw data) to keep the main context clean for synthesis.

Typical research areas (adjust as appropriate):

• Codebase analysis: Existing architecture patterns, integration points, code conventions (using Grep/Glob)
• External research: Dependencies, APIs, latest best practices (using WebSearch/WebFetch)
• Context loading (usually main context): Steering files, design principles, discovery rules, templates

For simple additions, skip subagent dispatch entirely and do a quick pattern check in main context.

After all findings return, synthesize in main context before proceeding.

3. Retain Discovery Findings for Step 3:

   • External API contracts and constraints
   • Technology decisions with rationale
   • Existing patterns to follow or extend
   • Integration points and dependencies
   • Identified risks and mitigation strategies
   • Boundary candidates, out-of-boundary decisions, and likely revalidation triggers

4. Persist Findings to Research Log:

   • Create or update {{KIRO_DIR}}/specs/{feature}/research.md using the shared template
   • Summarize discovery scope and key findings
   • Record investigations with sources and implications
   • Document architecture pattern evaluation, design decisions, and risks
   • If research.md already exists, briefly record consulted skills and the guidance used in its existing research notes.
   • Use the language specified in spec.json when writing or updating research.md

Step 3: Synthesis

Apply design synthesis to discovery findings before writing.

• Read and apply rules/design-synthesis.md from this skill's directory
• This step requires the full picture from discovery findings — execute in main context, not in a subagent
• Record synthesis outcomes (generalizations found, build-vs-adopt decisions, simplifications) in research.md

Step 4: Generate Design Draft

1. Generate Design Draft:
   • Follow specs/design.md template structure and generation instructions strictly
   • Boundary-first requirement: Before expanding supporting sections, make the boundary explicit. The draft must clearly define what this spec owns, what it does not own, which dependencies are allowed, and what changes would require downstream revalidation.
   • Integrate all discovery findings and synthesis outcomes: Use researched information (APIs, patterns, technologies) and synthesis decisions (generalizations, build-vs-adopt, simplifications) throughout component definitions, architecture decisions, and integration points
   • File Structure Plan (required): Populate the File Structure Plan section with concrete file paths and responsibilities. Analyze the codebase to determine which files need to be created vs. modified. Each file must have one clear responsibility. This section directly drives task _Boundary:_ annotations and implementation Task Briefs — vague file structures produce vague implementations.
   • Testing Strategy: Derive test items from requirements' acceptance criteria, not generic patterns. Each test item should reference specific components and behaviors from this design. E2E paths must map to the critical user flows identified in requirements. Avoid vague entries like "test login works" -- instead specify what is being verified and why it matters.
   • If existing design.md found in Step 1, use it as reference context (merge mode)
   • Apply design rules: Type Safety, Visual Communication, Formal Tone
   • Use language specified in spec.json
   • Keep this as a draft until the review gate passes; do not write design.md yet

Step 5: Review Design Draft

• Read and apply rules/design-review-gate.md from this skill's directory
• Verify requirements coverage, architecture readiness, and implementation executability before finalizing the design
• If issues are local to the draft, repair the design and review again
• Keep the review bounded to at most 2 repair passes
• If the draft exposes a real requirements/design gap, stop and return to requirements clarification instead of papering over it in design.md

Step 6: Finalize Design Document

1. Write Final Design:

   • Write {{KIRO_DIR}}/specs/{feature}/design.md only after the design review gate passes
   • Write research.md with discovery findings and synthesis outcomes (if not already written)

2. Update Metadata in spec.json:

   • Set phase: "design-generated"
   • Set approvals.design.generated: true, approved: false
   • Set approvals.requirements.approved: true
   • Update updated_at timestamp

Critical Constraints

• Type Safety:
  • Enforce strong typing aligned with the project's technology stack.
  • For statically typed languages, define explicit types/interfaces and avoid unsafe casts.
  • For TypeScript, never use any; prefer precise types and generics.
  • For dynamically typed languages, provide type hints/annotations where available (e.g., Python type hints) and validate inputs at boundaries.
  • Document public interfaces and contracts clearly to ensure cross-component type safety.
• Requirements Traceability IDs: Use numeric requirement IDs only (e.g. "1.1", "1.2", "3.1", "3.3") exactly as defined in requirements.md. Do not invent new IDs or use alphabetic labels.

Output Description

Command execution output (separate from design.md content):

Provide brief summary in the language specified in spec.json:

1. Status: Confirm design document generated at {{KIRO_DIR}}/specs/{feature}/design.md
2. Discovery Type: Which discovery process was executed (full/light/minimal)
3. Key Findings: 2-3 critical insights from discovery that shaped the design
4. Review Gate: Confirm the design review gate passed
5. Next Action: Approval workflow guidance (see Safety & Fallback)
6. Research Log: Confirm research.md updated with latest decisions

Format: Concise Markdown (under 200 words) - this is the command output, NOT the design document itself

Note: The actual design document follows {{KIRO_DIR}}/settings/templates/specs/design.md structure.

Safety & Fallback

Error Scenarios

Requirements Not Approved:

• Stop Execution: Cannot proceed without approved requirements
• User Message: "Requirements not yet approved. Approval required before design generation."
• Suggested Action: "Run /kiro-spec-design {feature} -y to auto-approve requirements and proceed"

Missing Requirements:

• Stop Execution: Requirements document must exist
• User Message: "No requirements.md found at {{KIRO_DIR}}/specs/{feature}/requirements.md"
• Suggested Action: "Run /kiro-spec-requirements {feature} to generate requirements first"

Template Missing:

• User Message: "Template file missing at {{KIRO_DIR}}/settings/templates/specs/design.md"
• Suggested Action: "Check repository setup or restore template file"
• Fallback: Use inline basic structure with warning

Steering Context Missing:

• Warning: "Steering directory empty or missing - design may not align with project standards"
• Proceed: Continue with generation but note limitation in output

Invalid Requirement IDs:

• Stop Execution: If requirements.md is missing numeric IDs or uses non-numeric headings (for example, "Requirement A"), stop and instruct the user to fix requirements.md before continuing.

Spec Gap Found During Design Review:

• Stop Execution: Do not write a patched-over design.md
• User Message: "Design review found a real spec gap or ambiguity that must be resolved before design can be finalized."
• Suggested Action: Clarify or fix requirements.md, then re-run /kiro-spec-design {feature}

Next Phase: Task Generation

If Design Approved:

• Optional: Run /kiro-validate-design {feature} for interactive quality review
• Run /kiro-spec-tasks {feature} to generate implementation tasks
• Or /kiro-spec-tasks {feature} -y to auto-approve and proceed directly

If Modifications Needed:

• Provide feedback and re-run /kiro-spec-design {feature}
• Existing design used as reference (merge mode)