implement-phases

Parse phase plans, detect dependencies, and coordinate sub-agents for phased implementation.

34|3|Updated Oct 17, 2025

Search Tags:#planning #coordination #execution #phases #orchestrate #sub-agent

Ready to run

npx skills add https://github.com/charlesjones-dev/claude-code-plugins-dev --skill implement-phases

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: implement-phases
Source: https://github.com/charlesjones-dev/claude-code-plugins-dev/tree/main/plugins/ai-workflow/skills/implement-phases
Command: npx skills add https://github.com/charlesjones-dev/claude-code-plugins-dev --skill implement-phases

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides methodology for analyzing plan documents, determining optimal execution strategies, and coordinating phase implementation through sub-agents.

Core Features & Use Cases

Plan extraction: Parses a phase plan to understand scope and acceptance criteria.
Dependency analysis: Detects explicit and implicit dependencies between phases.
Execution strategy: Chooses parallel vs. sequential execution per phase.
Coordination: Spawns sub-agents for each phase and aggregates results.
Failure handling: Detects and isolates phase failures without affecting others.

Quick Start

Parse the plan document to extract phases.
For each phase, spawn a Task sub-agent with a full-phase prompt and acceptance criteria.
After all sub-agents complete, aggregate results and present a final report.

Frequently Asked Questions about implement-phases

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

FAQPage Schema

How do I coordinate work across multiple phases with parallel and sequential execution?▼

Phased coordination analyzes your plan document to identify dependencies between phases, then determines whether each phase runs in parallel or sequentially. Sub-agents execute each phase independently, and results aggregate into a final structured report, allowing you to orchestrate complex multi-phase projects without manual sequencing.

What's the best way to break down a large implementation into manageable phases?▼

Parse your plan document to extract distinct phases with explicit scope and acceptance criteria. The Skill detects both explicit dependencies (phase B requires phase A) and implicit ones (shared resources, timing constraints), then spawns a sub-agent per phase to handle implementation while the coordinator manages handoffs and failure isolation.

Can I run phases in parallel, or do they have to execute sequentially?▼

Execution strategy adapts to your dependencies. Independent phases run in parallel for speed; dependent phases run sequentially. The Skill analyzes your plan to choose the optimal strategy automatically, and sub-agents execute concurrently or in order accordingly, with isolated failure handling so one phase's failure doesn't block others.

How do I handle failures when coordinating multiple phases?▼

Failure handling detects and isolates phase failures without cascading to dependent phases or the overall workflow. When a phase fails, the coordinator reports the failure, preserves results from completed phases, and optionally retries or halts based on dependency criticality, giving you fine-grained control over fault tolerance.

What information do I need to prepare before using phase coordination?▼

Prepare a plan document that specifies phases, their scope, acceptance criteria, and any explicit dependencies or execution constraints. The Skill extracts phases from this document and handles dependency detection and execution strategy internally, so you provide only the plan; sub-agent spawning and aggregation are automatic.

How does phase coordination aggregate results from multiple sub-agents?▼

After all sub-agents complete their phases, the coordinator collects structured results from each phase—outputs, artifacts, and status—and assembles them into a final report. Results preserve phase execution order and dependency chain, letting you trace outcomes back to their source phase and verify acceptance criteria across the full workflow.