executor-workflow

Orchestrate wave-based execution of multi-layer development plans with validation and checkpoints.

1|Updated Mar 29, 2026
One-click install
npx skills add https://github.com/dmedina-dev/dev-forge --skill executor-workflow
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: executor-workflow
Source: https://github.com/dmedina-dev/dev-forge/tree/main/plugins/forge-executor/skills/executor-workflow
Command: npx skills add https://github.com/dmedina-dev/dev-forge --skill executor-workflow

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Provides a structured, auditable way to execute multi-layer development plans by breaking work into waves with validation, checkpoints, and controlled rollback so complex features can be delivered incrementally and safely.

Core Features & Use Cases

  • Wave orchestration: Sequentially execute wave units that include validation, baseline checks, TDD, review, merge, and checkpoint tagging.
  • Branching and checkpoint strategy: Enforce flow and per-wave branch patterns and annotated checkpoint tags to preserve history and enable targeted rollback.
  • Decision logging and safety: Document autonomous decisions and surface BLOCKERs for user input, keeping failed waves available for forensic inspection.
  • Use Case: Use this when implementing a feature spanning data, API, and UI layers where each layer should be delivered, validated, and optionally rolled back independently.

Quick Start

Trigger the executor by asking execute plan or invoking /execute-plan with the path to your wave-structured plan.

Frequently Asked Questions about executor-workflow

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

FAQPage Schema
How do I execute multi-layer development plans with incremental rollbacks?

Multi-layer development plans can be executed incrementally by orchestrating wave-based execution. This approach validates baseline tests, manages branch patterns, and applies annotated checkpoint tags to preserve history and enable targeted rollback safely.

What is wave-based plan execution for software development?

Wave-based plan execution is a structured method for delivering complex features by breaking work into sequential units. Each wave includes validation, TDD, review, merge, and checkpoint tagging to ensure safe, incremental delivery across logical layers.

How do I manage Git branch checkpoints during feature development?

Git branch checkpoints are managed by enforcing per-wave branch patterns and annotated checkpoint tags. This preserves commit history and enables targeted rollback if a wave fails or requires forensic inspection.

When do I need wave-based execution for my development project?

Wave-based execution is needed when a plan spans three or more logical layers, such as data, API, and UI. It is required when partial delivery, validation, and rollback granularity are necessary for safe feature implementation.

How do I handle blockers during automated plan execution?

Blockers during automated plan execution are handled by pausing the workflow exclusively for user-declared blockers. The executor logs autonomous decisions and surfaces these blockers for user input, keeping failed waves available for review.

Can I use TDD checkpoints with multi-layer feature delivery?

TDD checkpoints can be integrated into multi-layer feature delivery by enforcing per-wave baseline tests. Each wave unit applies test-driven development validation before proceeding to review, merge, and checkpoint tagging.