kiro-impl

Implement approved development tasks using test-driven development and subagent dispatch.

Updated Apr 17, 2026
One-click install
npx skills add https://github.com/BarryYin/Hermes-sdd --skill kiro-impl-barryyin
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: kiro-impl
Source: https://github.com/BarryYin/Hermes-sdd/tree/main/skills/kiro-impl
Command: npx skills add https://github.com/BarryYin/Hermes-sdd --skill kiro-impl-barryyin

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill orchestrates test-driven implementation of approved tasks from a spec, removing manual coordination by dispatching implementer, reviewer, and debugger subagents and enforcing strict commit and validation discipline.

Core Features & Use Cases

  • Autonomous Task Execution: Run all pending tasks or selected tasks with one-subtask-per-iteration subagent dispatch and independent reviews.
  • TDD Enforcement & Feature Flags: Ensure tests are written first, follow RED → GREEN → REFACTOR cycles, and apply feature-flag protocol for behavioral changes.
  • Bounded Debug & Safe Commits: Apply structured debug cycles, bounded remediation, selective staging of changed files, and verifier gates before marking tasks complete.
  • Use Case: Turn an approved feature spec into production code with automated implementer reviews, explicit status parsing, and safe, scoped commits.

Quick Start

Load the kiro-impl skill and run it with the feature name to implement approved tasks using TDD and automated subagents.

Frequently Asked Questions about kiro-impl

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

FAQPage Schema
How do I autonomously implement spec-driven development tasks using TDD?

Autonomous spec-driven TDD implementation works by dispatching subagents to iteratively write tests first, review code, debug within bounded cycles, and selectively stage git commits based on approved tasks defined in a tasks.md file.

What is the RED GREEN REFACTOR cycle in test-driven development?

The RED GREEN REFACTOR cycle in test-driven development enforces writing failing tests first, implementing minimal code to pass them, then refactoring. This Skill automates that cycle using dispatched subagents for implementation and review.

How do I enforce test-first workflow when implementing repository features?

Enforcing a test-first workflow requires writing tests before implementation code, followed by reviewer verification and selective git staging. This Skill automates that discipline by dispatching implementer and reviewer subagents for each iteration.

Can I run selected tasks from a feature spec instead of all pending tasks?

You can run selected tasks or all pending tasks from a feature spec. The Skill dispatches one subtask per iteration with independent subagent reviews, allowing targeted implementation of specific approved items.

Does autonomous code implementation work with selective git staging?

Autonomous code implementation works with selective git staging by staging only changed files relevant to the completed task. Verifier gates must pass before marking tasks complete, ensuring scoped and safe commits.

What are the limitations of bounded debug cycles in autonomous task execution?

Bounded debug cycles in autonomous task execution limit remediation attempts to prevent infinite debugging loops. When structured debug cycles exceed their bound, the Skill stops to avoid runaway cycles and requires intervention.