Skip to content
cccskills
FreePublished on GitHub

kiro-validate-design

Review a technical design before implementation by comparing it with requirements and existing code patterns. Receive up to three critical concerns, recognized strengths, and a clear decision on whether to proceed, with reasons and practical next steps.

OriginalShow the original description

Interactive technical design quality review and validation. Use when reviewing design before implementation.

See how to install

Good for

  • Reviewing a technical design before implementation
  • Identifying the most important design concerns
  • Deciding whether a feature is ready to build
  • Rechecking a revised design

Files included (1)

  • SKILL.md5.2 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

kiro-validate-design Skill

Role

You are a specialized skill for conducting interactive quality review of technical design to ensure readiness for implementation.

Core Mission

  • Mission: Conduct interactive quality review of technical design to ensure readiness for implementation
  • Success Criteria:
    • Critical issues identified (maximum 3 most important concerns)
    • Balanced assessment with strengths recognized
    • Clear GO/NO-GO decision with rationale
    • Actionable feedback for improvements if needed

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:

  • Read {{KIRO_DIR}}/specs/{feature}/spec.json for language and metadata
  • Read {{KIRO_DIR}}/specs/{feature}/requirements.md for requirements
  • Read {{KIRO_DIR}}/specs/{feature}/design.md for design document
  • Core steering context: product.md, tech.md, structure.md
  • Additional steering files only when directly relevant to architecture boundaries, integrations, runtime prerequisites, domain rules, 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.

Parallel Research

The following research areas are independent and can be executed in parallel:

  1. Context & rules loading: Spec documents, core steering, task-relevant extra steering, relevant local agent skills/playbooks, and rules/design-review.md from this skill's directory for review criteria
  2. Codebase pattern survey: Gather existing architecture patterns, naming conventions, and component structure from the codebase to use as reference during review

After all parallel research completes, synthesize findings for review.

Step 2: Execute Design Review

  • Reference conversation history: leverage prior requirements discussion and user's stated design intent
  • Follow design-review.md process: Analysis → Critical Issues → Strengths → GO/NO-GO
  • Limit to 3 most important concerns
  • Engage interactively with user — ask clarifying questions, propose alternatives
  • Use language specified in spec.json for output

Step 3: Decision and Next Steps

  • Clear GO/NO-GO decision with rationale
  • Provide specific actionable next steps (see Next Phase below)

Important Constraints

  • Quality assurance, not perfection seeking: Accept acceptable risk
  • Critical focus only: Maximum 3 issues, only those significantly impacting success
  • Conversation-aware: Leverage discussion history for requirements context and user intent
  • Interactive approach: Engage in dialogue, ask clarifying questions, propose alternatives
  • Balanced assessment: Recognize both strengths and weaknesses
  • Actionable feedback: All suggestions must be implementable
  • Context Discipline: Start with core steering and expand only with review-relevant steering or local skills/playbooks selected above

Tool Guidance

  • Read first: Load spec, core steering, relevant local playbooks/agent skills, and rules before review
  • Grep if needed: Search codebase for pattern validation or integration checks
  • Interactive: Engage with user throughout the review process

Output Description

Provide output in the language specified in spec.json with:

  1. Review Summary: Brief overview (2-3 sentences) of design quality and readiness
  2. Critical Issues: Maximum 3, following design-review.md format
  3. Design Strengths: 1-2 positive aspects
  4. Final Assessment: GO/NO-GO decision with rationale and next steps

Format Requirements:

  • Use Markdown headings for clarity
  • Follow design-review.md output format
  • Keep summary concise

Safety & Fallback

Error Scenarios

  • Missing Design: If design.md doesn't exist, stop with message: "Run /kiro-spec-design {feature} first to generate design document"
  • Design Not Generated: If design phase not marked as generated in spec.json, warn but proceed with review
  • Empty Steering Directory: Warn user that project context is missing and may affect review quality
  • Language Undefined: Default to English (en) if spec.json doesn't specify language

Next Phase: Task Generation

If Design Passes Validation (GO Decision):

  • Apply any suggested improvements if agreed
  • Run /kiro-spec-tasks {feature} to generate implementation tasks
  • Or /kiro-spec-tasks {feature} -y to auto-approve and proceed directly

If Design Needs Revision (NO-GO Decision):

  • Address critical issues identified in review
  • Re-run /kiro-spec-design {feature} with improvements
  • Re-validate with /kiro-validate-design {feature}

Note: Design validation is recommended but optional. Quality review helps catch issues early.

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

cc-sdd-new-agent

FreeSummary

Add coding-agent support to cc-sdd through a documented workflow. Research the agent’s official formats, prepare an integration plan, implement registry entries and templates, and verify generated files, including Japanese and English output.

  • Adding support for a new coding agent
  • Adding an agent variant with subagent support
  • Planning migration to SKILL.md-based templates
gotalab/cc-sdd3.7KUpdated Oct 22, 2026

kiro-debug

FreeSummary

Investigate blocked implementation work and recurring failures using error output, code changes, configuration, and dependency evidence. Get a root cause report with a focused repair plan, verification steps, and a recommendation to retry, block, or seek human input.

  • Investigating an implementation blocker
  • Finding why repeated fixes keep failing
  • Checking runtime and dependency conflicts
gotalab/cc-sdd3.7KUpdated Oct 22, 2026

kiro-discovery

FreeSummary

Clarify a development request through structured questions and choose a practical next step: update an existing specification, create new ones, or implement directly. For new specifications, record scope, approach, and dependencies in planning files.

  • Clarify a development idea before defining requirements
  • Choose between updating a specification and implementing directly
  • Split a large request into features with explicit dependencies
gotalab/cc-sdd3.7KUpdated Oct 22, 2026

kiro-impl

FreeSummary

Implement approved tasks through test-driven development, writing tests before code. Run all pending tasks sequentially with subagents or select tasks for direct execution, then track completion using reviews and verification evidence.

  • Running all pending approved implementation tasks
  • Implementing selected tasks by number
  • Developing features with tests written first
gotalab/cc-sdd3.7KUpdated Oct 22, 2026

kiro-impl

FreeSummary

Implement approved development tasks one at a time using test-driven development, which starts with a failing test. Process all pending tasks or selected ones, check changes against requirements and design, and update progress after review and completion verification.

  • Working through all approved pending tasks
  • Implementing selected task numbers
  • Developing features with tests written first
gotalab/cc-sdd3.7KUpdated Oct 22, 2026

kiro-impl

FreeSummary

Implement approved tasks using test-driven development, writing tests before code. Run all pending tasks one at a time or select specific tasks, with configurable review and verification before updating completion status.

  • Implement all pending tasks from an approved plan
  • Work on selected task numbers
  • Develop features by writing tests before code
gotalab/cc-sdd3.7KUpdated Oct 22, 2026

See all skills by gotalab

Report a problem with this skill