kiro-impl

Implement spec-defined feature tasks with TDD and subagent reviews.

3.6k|274|Updated Jul 17, 2025
One-click install
npx skills add https://github.com/gotalab/cc-sdd --skill kiro-impl
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: kiro-impl
Source: https://github.com/gotalab/cc-sdd/tree/main/tools/cc-sdd/templates/agents/claude-code-skills/skills/kiro-impl
Command: npx skills add https://github.com/gotalab/cc-sdd --skill kiro-impl

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Implements long-running, spec-driven task implementation so repositories with approved specs can be converted into production code reliably, with TDD-first discipline, per-task reviewers, and controlled commits to avoid regressions and scope creep.

Core Features & Use Cases

  • Autonomous and Manual Modes: Run all pending tasks as independent subagents or execute selected tasks directly in the main context.
  • TDD-first Workflow: Enforces RED → GREEN → REFACTOR with feature-flag protocol for behavioral changes.
  • Gated Review & Debug Loop: Dispatches independent implementer, reviewer, and debug subagents with strict structured status parsing, selective staging, and bounded remediation rounds.
  • Use Case: Convert an approved feature spec into incremental, reviewed commits where each task is implemented, reviewed, and verified against repository validation commands.

Quick Start

Invoke the kiro-impl skill with a feature name to run TDD-driven task implementations and per-task reviews, for example: /kiro-impl my-feature [1.1] --review required

Frequently Asked Questions about kiro-impl

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate test-driven development implementation for spec-driven feature tasks?

Automated TDD implementation executes spec-defined feature tasks through a RED, GREEN, and REFACTOR workflow, dispatching native subagents to write tests first and verify behavior before production code changes are committed.

Can I run a code review loop automatically after implementing each feature task?

Yes, a gated review loop automatically dispatches an independent reviewer subagent after implementation, parsing structured verdicts and selectively staging commits to ensure each task passes validation before proceeding.

How does subagent task orchestration handle debugging during TDD implementation?

Subagent task orchestration dispatches an optional debugger subagent within a bounded remediation loop when tests fail, isolating fixes and verifying boundary checks before the reviewer subagent re-evaluates the task.

What is the best way to convert approved feature specs into incremental reviewed commits?

Converting approved specs into reviewed commits requires dispatching independent implementer and reviewer subagents per task, enforcing test-driven development discipline and selective staging to prevent regressions and scope creep.

Does TDD task implementation require running all pending tasks autonomously?

No, TDD task implementation supports both autonomous and manual modes, allowing you to run all pending tasks as independent subagents or execute selected tasks directly within the main context.

Why does autonomous task implementation enforce selective commits and validation gates?

Autonomous task implementation enforces selective commits and final validation gates to prevent regressions and scope creep, ensuring all repository validation commands pass before code changes are merged.