skills.rest
softwareByAndi
softwareByAndiCOMMUNITY
Explore all skills by this author →
GitHub

epic-commander

Orchestrate multi-stage software epic implementation from a specification file.

Updated Feb 15, 2026
Search Tags:#automation#project management#software development#orchestration#agile#decomposition#epic
One-click install
npx skills add https://github.com/softwareByAndi/workflow --skill epic-commander
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: epic-commander
Source: https://github.com/softwareByAndi/workflow/tree/main/.claude/skills/epic-commander
Command: npx skills add https://github.com/softwareByAndi/workflow --skill epic-commander

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill automates the complex process of breaking down large software features or epics into manageable, executable stages, ensuring a structured and efficient implementation pipeline.

Core Features & Use Cases

  • Automated Epic Decomposition: Transforms a high-level spec file into a series of sequential, actionable stages.
  • Domain-Driven Design: Classifies requirements into code domains, orchestrates parallel design and review processes for each domain.
  • Adaptive Execution: Manages sequential execution of stages with built-in retry and halt gates for robust error handling.
  • Use Case: You have a detailed specification for a new user authentication system. This Skill will analyze the spec, assign components to relevant code domains (e.g., UI, backend API, database), generate designs for each, get them reviewed, and then assemble them into a phased execution plan.

Quick Start

Use the epic-commander skill to orchestrate the implementation of the epic defined in the file '/path/to/your/epic-spec.md'.

Frequently Asked Questions about epic-commander

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

FAQPage Schema
How do I automate project management for large software epics?▼

You can automate epic decomposition by providing a detailed specification file on disk. The Skill reads the spec, classifies requirements into code domains, and generates a phased execution plan for the software project.

What is the process for decomposing detailed software specifications into executable stages?▼

Decomposing detailed specifications involves classifying requirements into code domains, orchestrating parallel architect design and review processes, and sequentially executing stages with adaptive gates and built-in retry logic for error handling.

Does epic orchestration require a specific input format for the software specification?▼

Yes, epic orchestration requires a detailed specification file saved on disk, such as a markdown file. The Skill uses this on-disk spec file as the sole input to drive the end-to-end implementation pipeline.

Can I use domain-driven design to parallelize software development tasks?▼

Yes, you can use domain-driven design to parallelize software development. The Skill classifies requirements into distinct code domains like UI or backend API, then orchestrates parallel design and review processes for each domain.

How does adaptive execution handle errors during sequential stage implementation?▼

Adaptive execution manages errors during sequential stage implementation by utilizing built-in retry mechanisms and halt gates. This ensures robust error handling and prevents the pipeline from proceeding until issues are resolved.

Related Skills

Explore More Software Engineering Skills→
forwardimpactforwardimpact
4

sync-apple-mail

Sync macOS Mail email threads from SQLite into markdown files.

Official
Advanced
CJ-1981CJ-1981

moai-workflow-tdd

Implement the RED-GREEN-REFACTOR cycle for test-driven software development.

Community
Intermediate
owenlim225owenlim225

blueprintkit-plugin

Consolidate project planning sections and specialized Claude Skills for lifecycle management.

Community
Advanced
GrinRusGrinRus

task-slicing

Decompose vague roadmap items into small reviewable tasks with verification criteria.

Community
Intermediate