create-implementation-plan

Name: create-implementation-plan
Availability: InStock
Author: tamago0224

Generate phase-based implementation plans with explicit file paths and validation criteria.

Updated Mar 8, 2026

Search Tags:#automation #planning #architecture #specification #software-engineering #implementation-plan #ai-to-ai

Ready to run

npx skills add https://github.com/tamago0224/kuroshio-mta --skill create-implementation-plan-tamago0224

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: create-implementation-plan
Source: https://github.com/tamago0224/kuroshio-mta/tree/main/.agents/skills/create-implementation-plan
Command: npx skills add https://github.com/tamago0224/kuroshio-mta --skill create-implementation-plan-tamago0224

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill removes ambiguity from implementation planning by producing fully deterministic, machine-parseable implementation plans for new features, refactors, upgrades, design changes, and infrastructure work so that AI agents or humans can execute each step without interpretation.

Core Features & Use Cases

Structured, Atomic Phases: Produces phase-based plans composed of atomic, independently executable tasks with explicit completion criteria.
Machine-parseable Specifications: Enforces templates with required front matter, standardized identifier prefixes (REQ-, TASK-, etc.), explicit file paths, and validation rules for automated verification.
Use Case: Prepare a production-ready, versioned implementation plan to refactor an authentication module, including file-level edits, tests to add, and measurable validation steps.

Quick Start

Generate a complete, machine-readable implementation plan for migrating the local spool backend to an S3-compatible storage backend, including phase goals, TASK- IDs, exact file paths to change, and automated validation checks.

Frequently Asked Questions about create-implementation-plan

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

FAQPage Schema

What is a machine-readable implementation plan and when do I need one?▼

A machine-readable implementation plan provides deterministic, phase-based atomic tasks with explicit file paths, standardized identifiers, and validation criteria for automated agent execution. You need this format when automating feature development, architecture changes, refactoring tasks, or infrastructure upgrades without human interpretation.

How do I generate a structured implementation plan for refactoring a software module?▼

To generate a structured implementation plan for refactoring, provide the target module details to produce phase-based atomic tasks with explicit file paths, standardized TASK- identifiers, tests to add, and measurable validation steps. This ensures deterministic, machine-parseable specifications for automated verification of the refactoring tasks.

Can I use this for infrastructure upgrades and package migrations?▼

Yes, you can generate deterministic, machine-readable plans for infrastructure upgrades and package migrations. The Skill produces phase-based plans with exact file paths to change, explicit completion criteria, and automated validation checks tailored for infrastructure work and deployments.

Does the generated implementation plan include automated validation rules?▼

Yes, the generated implementation plan enforces templates with required Markdown front matter, standardized identifier prefixes like REQ-, explicit file paths, and validation rules for automated verification. These machine-parseable specifications ensure each atomic task has measurable completion criteria.

What is the best way to prepare machine-parseable specifications for AI agent execution?▼

The best way to prepare machine-parseable specifications is to generate phase-based plans composed of atomic, independently executable tasks. This approach enforces required front matter, standardized identifier prefixes, explicit file paths, and validation rules, removing ambiguity for automated agent execution during software engineering tasks.