execute-plan

Execute hierarchical engineering plans phase-by-phase with TDD and stateful memory.

Updated Mar 8, 2026
One-click install
npx skills add https://github.com/luyzkk/Anti-Vibe-Coding --skill execute-plan-luyzkk
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: execute-plan
Source: https://github.com/luyzkk/Anti-Vibe-Coding/tree/main/skills/execute-plan
Command: npx skills add https://github.com/luyzkk/Anti-Vibe-Coding --skill execute-plan-luyzkk

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

execute-plan turns a hierarchical engineering plan into reliable, verifiable progress by orchestrating isolated subagents per phase and keeping TDD and state/memory consistent.

Core Features & Use Cases

  • Hierarchical plan execution: Runs phase-by-phase from PLAN/STATE/MEMORY artifacts, supporting the v2 folder-based layout and a legacy v1 flat PLAN format.
  • TDD with RED/GREEN isolation: Enforces RED-first test creation and GREEN-only minimal implementation while keeping context clean between subagents.
  • Live progress tracking & decision capture: Updates STATE.md and appends rich implementation notes (DI-, BUG-, GT-, DEV-) into the right plan MEMORY.md sections as phases complete.
  • Completion handling for automation: Emits a machine-readable completion signal and can move completed plans to a terminal directory to support downstream orchestration.

Quick Start

Run execute-plan for your feature plan by choosing (or providing) the PLAN.md/active plan folder and confirming execution when prompted.

Frequently Asked Questions about execute-plan

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

FAQPage Schema
How do I execute hierarchical engineering plans phase by phase with TDD?

You execute hierarchical plans phase-by-phase by orchestrating isolated subagents that enforce RED-first test creation and GREEN-only minimal implementation while keeping context clean between cycles. The process updates stateful memory and validates completion criteria per phase.

What is the best way to orchestrate subagents for isolated TDD cycles?

Orchestrating subagents for isolated TDD cycles involves dispatching phase-specific tasks to clean contexts, enforcing deterministic RED/GREEN test constraints, and capturing live progress into STATE.md and MEMORY.md artifacts for reliable execution.

How does stateful memory tracking work during multi-phase plan execution?

Stateful memory tracking works by updating STATE.md and appending rich implementation notes like DI-*, BUG-*, and DEV-* into specific MEMORY.md sections as each phase completes, ensuring consistent context retrieval across isolated subagents.

Can I use this plan execution approach with a legacy flat PLAN.md format?

Yes, you can use this approach with a legacy flat PLAN.md format. The execution logic supports both the v2 folder-based layout with waves/tasks and the v1 flat plan format, requiring interactive control and post-phase validation for both.

How do I emit a completion signal for downstream automation after plan execution?

You emit a machine-readable completion signal and optionally move completed plans to a terminal directory after validating all phase completion criteria. This deterministic orchestration output supports downstream automation workflows.

Why does isolated agent context matter for test-driven development workflows?

Isolated agent context matters because it enforces strict TDD boundaries by preventing context bleed between RED and GREEN phases. This deterministic isolation ensures minimal implementation and reliable state updates across complex hierarchical plans.