skills.rest
anderson-0
anderson-0COMMUNITY
Explore all skills by this author →
GitHub

executing-plans

Execute implementation plans with wave-based task coordination and persistent progress tracking.

4|2|Updated Apr 1, 2026
Search Tags:#planning#software development#implementation#task tracking#status tracking#wave execution
One-click install
npx skills add https://github.com/anderson-0/mighty-powers --skill executing-plans-anderson-0
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: executing-plans
Source: https://github.com/anderson-0/mighty-powers/tree/main/skills/executing-plans
Command: npx skills add https://github.com/anderson-0/mighty-powers --skill executing-plans-anderson-0

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the challenge of turning detailed implementation plans into reliable development work by coordinating execution steps, tracking progress, and preserving state across interruptions.

Core Features & Use Cases

  • Wave-Based Execution: Runs implementation tasks in dependency-aware waves with parallel dispatch for independent work and sequential handling for shared changes.
  • Persistent Progress Tracking: Maintains status.yaml updates throughout execution so work can resume accurately after crashes or session interruptions.
  • Use Case: Apply this Skill when a completed technical plan needs to be implemented across multiple files with verification checkpoints and coordinated task completion.

Quick Start

Use the executing-plans skill to implement the prepared development plan and track progress through completion.

Frequently Asked Questions about executing-plans

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

FAQPage Schema
How do I execute a multi-file software implementation plan with dependency-aware task ordering?▼

You can execute a software implementation plan using wave-based delivery, which coordinates dependency-aware execution by running independent tasks in parallel and sequential tasks in ordered waves.

What is the best way to track development progress and resume implementation after a session crash?▼

Persistent progress tracking maintains a status.yaml file throughout execution, allowing you to accurately resume development work after session interruptions or crashes by reading the last saved state.

How does wave-based execution coordinate parallel tasks during software development?▼

Wave-based execution groups implementation tasks into dependency-aware waves, dispatching independent work in parallel while sequentially handling tasks that require shared changes or have execution dependencies.

Can I use this approach for multi-file changes that require verification checkpoints?▼

Yes, this approach applies to software development workflows involving multi-file changes by inserting validation steps and verification checkpoints to safely complete planned engineering work.

Do I need a completed technical plan before starting wave-based task execution?▼

Yes, you need a prepared technical implementation plan to input into the system, as the execution mechanism requires defined tasks, dependencies, and verification steps to coordinate the work safely.

What are the limitations of using persistent status tracking for software implementation?▼

Persistent progress tracking requires manual status.yaml updates throughout execution, meaning the system relies on the accuracy of these recorded checkpoints to correctly resume work after interruptions.

Related Skills

Explore More Software Engineering Skills→
anderson-0anderson-0
4

writing-plans

Create detailed implementation plans with task decomposition and dependency ordering.

Community
Advanced
jpoutrinjpoutrin
14

parallel-execution

Execute multiple Claude Code agents in parallel with wave dependencies and git worktrees.

Community
Advanced
obsfxobsfx

trekker

Track tasks persistently across sessions using Trekker as the source of truth.

Community
Intermediate
tmalcolm-0607tmalcolm-0607

mad-parallel

Orchestrate wave-based parallel feature implementation across isolated git worktrees.

Community
Advanced