exec-plan

Execute plan pipelines by running exec-spec and quick-review per story.

3|2|Updated Mar 13, 2026
One-click install
npx skills add https://github.com/IT-HUSET/andthen --skill exec-plan-it-huset
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: exec-plan
Source: https://github.com/IT-HUSET/andthen/tree/main/plugin/skills/exec-plan
Command: npx skills add https://github.com/IT-HUSET/andthen --skill exec-plan-it-huset

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Orchestrates end-to-end execution of fully-specced plan bundles by coordinating per-story execution, reviews, and final gap assessments, ensuring consistent state and artifacts.

Core Features & Use Cases

  • End-to-end plan orchestration: runs exec-spec and quick-review for each story, then a final gap review.
  • Team and sub-agent support: works with Agent Teams (--team) or portable sub-agents.
  • Artifact management: validates FIS presence for each story, writes plan/state changes, and handles worktree-based deferrals in team mode.
  • Use Case: A software project with multi-story specs can be executed autonomously by coordinating sub-agents to implement and review stories, plus a final gap review to catch missing gaps.

Quick Start

Run /andthen:exec-plan with a plan directory and optional code repository to start executing all stories through exec-spec and quick-review.

Frequently Asked Questions about exec-plan

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

FAQPage Schema
How do I automate end-to-end plan execution for multi-story software specs?▼

End-to-end plan execution is orchestrated by running exec-spec and quick-review per story, followed by a final gap review. This coordinates sub-agents to implement and review stories autonomously, ensuring consistent state and artifacts across the entire plan pipeline.

What is wave-based execution in plan orchestration?▼

Wave-based execution is an orchestration mechanism that coordinates per-story prompts and sub-agent activities in structured waves. It processes fully-specced plan bundles by running exec-spec and quick-review sequentially for each story, then performs a final gap review on the entire plan.

Do I need a FIS for every story before running plan orchestration?▼

Yes, plan orchestration requires that every story in the plan.md already has a FIS. The skill validates FIS presence for each story before executing the pipeline, writing plan state changes, and handling worktree-based deferrals in team mode.

Can I use agent teams for plan execution or do I need sub-agents?▼

Plan execution supports both Agent Teams using the --team flag and portable sub-agents as a fallback. Team mode enables worktree-based deferrals for managing state, while sub-agents provide a portable alternative for coordinating per-story implementation and reviews.

How do I run autonomous story implementation and review across a full plan?▼

Run the plan execution command with a plan directory and optional code repository to start autonomous story implementation. The skill orchestrates sub-agents to implement each story through exec-spec, review it with quick-review, and perform a final gap review to catch missing gaps.

What happens if the final gap review finds missing gaps in the plan?▼

The final gap review catches missing gaps across the entire plan after all per-story execution and reviews complete. This verification step ensures consistent state and artifacts, validating that the coordinated sub-agent implementation covered all stories in the fully-specced plan bundle.