wave-executor

Execute phased implementation plans with TDD, parallel subagents, and quality gates.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/christian-byrne/ticket-to-pr-pipeline --skill wave-executor
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: wave-executor
Source: https://github.com/christian-byrne/ticket-to-pr-pipeline/tree/main/skills/wave-executor
Command: npx skills add https://github.com/christian-byrne/ticket-to-pr-pipeline --skill wave-executor

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill automates the end-to-end execution of phased implementation plans, ensuring every task, test, and quality gate is addressed with extreme discipline.

Core Features & Use Cases

  • Autonomous Execution: Runs through waves, phases, or milestones without human intervention.
  • Aggressive TDD: Mandates Red-Green-Refactor for all code, with extensive test case generation.
  • Quality Gates: Enforces strict formatting, linting, type-checking, and comprehensive testing before proceeding.
  • Use Case: You have a detailed roadmap for a new feature broken into 5 waves. Use this Skill to autonomously implement all waves, including writing all necessary tests, ensuring code quality, and performing rigorous verification at each checkpoint.

Quick Start

Use the wave-executor skill to fully implement the plan outlined in the project's roadmap.

Frequently Asked Questions about wave-executor

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

FAQPage Schema
How do I autonomously execute phased implementation plans with strict TDD enforcement?

Autonomous execution of phased implementation plans is achieved by dispatching parallel subagents through waves and milestones, mandating Red-Green-Refactor test-driven development, and enforcing strict quality gates for formatting, linting, and type-checking at every checkpoint.

What is aggressive Test-Driven Development and how does it apply to automated code implementation?

Aggressive Test-Driven Development mandates strict Red-Green-Refactor cycles for all code, generating extensive test cases before implementation. It applies to automated implementation by enforcing rigorous testing discipline and comprehensive verification at every phase checkpoint.

Does autonomous code execution work with existing agile roadmaps broken into multiple waves?

Autonomous code execution works directly with existing agile roadmaps by managing end-to-end execution of waves, phases, or milestones. It processes detailed plans broken into multiple waves, implementing all tasks without human intervention.

Can I enforce code quality gates like linting and type-checking during automated test generation?

Code quality gates including strict formatting, linting, type-checking, and comprehensive testing are enforced automatically during automated test generation. The execution process halts at verification checkpoints until all quality gates pass before proceeding.

What are the limitations of running autonomous full-send implementation without human intervention?

Autonomous full-send implementation requires a detailed pre-existing roadmap to function, as it operates with a mandate for 100% completion. Limitations include an inability to handle undefined phases and a rigid dependency on strict quality gates before advancing.