kiro-impl

Implement approved tasks from tasks.md using TDD and subagent review.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill automates the disciplined implementation of approved feature tasks by enforcing test-driven development, structured subagent handoffs, and gated reviewer verification so work is reliable and auditable.

Core Features & Use Cases

  • Autonomous Task Processing: Dispatches a fresh implementer subagent per task, runs a reviewer subagent, and repeats until all pending tasks are completed or blocked.
  • Manual Mode Support: Allows targeted TDD work for selected task numbers executed directly in the main context with the same RED→GREEN→REFACTOR discipline and reviewer protocol.
  • Robust Safety & Validation: Discovers repo validation commands, enforces selective git staging, bounded debug/review rounds, and records implementation notes to prevent regressions.
  • Use Case: Run a feature implementation across multiple small tasks defined in tasks.md, ensuring tests are written first, each change is reviewed, and only task-scoped files are committed.

Quick Start

Run the kiro-impl skill with the feature name to process pending tasks using TDD and subagent review.

Frequently Asked Questions about kiro-impl

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

FAQPage Schema
How do I automate TDD implementation for feature tasks listed in a markdown file?

You can automate TDD implementation by running a skill that processes tasks.md entries, dispatching fresh subagents per task to enforce RED→GREEN→REFACTOR cycles and reviewer verification. It writes tests before implementation and gates commits until review passes.

What is subagent orchestration for test-driven development?

Subagent orchestration for test-driven development dispatches isolated implementer and reviewer agents per task. This ensures unbiased code review, bounded debug rounds, and selective git staging for each task-scoped file change.

Can I run TDD task automation on specific tasks instead of the whole repository backlog?

Yes, you can use manual mode to target specific task numbers. It executes the same TDD discipline and reviewer protocol directly in the main context without processing the entire pending task list.

Does automated TDD implementation enforce selective git staging for task-scoped files?

Automated TDD implementation enforces selective git staging, ensuring only task-scoped files are committed. It discovers repository validation commands and records implementation notes to prevent regressions across multiple tasks.

What are the limitations of using autonomous subagents for feature implementation?

Autonomous subagent implementation uses bounded debug and review rounds to prevent infinite loops, meaning tasks may eventually be marked as blocked if validation fails repeatedly or reviewer checks cannot be passed within limits.

kiro-impl: What does this autonomous TDD implementer skill do?

Kiro-impl is an autonomous TDD implementer that processes approved development tasks using subagent reviews. It orchestrates fresh implementer and reviewer subagents per task to enforce test-first development and gated verification.