From ac-workflow
Decomposes large features into concrete, self-contained development phases with DAG dependencies. Each phase delivers testable code; outputs YAML manifest.
npx claudepluginhub waterplanai/agentic-config --plugin ac-workflowThis skill is limited to using the following tools:
Decomposes large features/bugs/chores into concrete, self-contained development phases.
Generates structured phased implementation plans from feature descriptions, sized for 30-50k token sub-agent contexts, with clarifying questions, acceptance criteria, and dependencies. Invoke before multi-phase execution.
Generates phased, dependency-ordered tasks from specifications with parallelization opportunities and tech-stack patterns for systematic feature implementation.
Use when you need to create an execution plan from a feature spec - handles worktree context, dispatches subagent for task decomposition, validates quality, analyzes dependencies, groups into phases, and commits the plan
Share bugs, ideas, or general feedback.
Decomposes large features/bugs/chores into concrete, self-contained development phases.
When given a feature/prompt/spec:
Assess overall feature complexity to guide phase count and mux-ospec modifier selection:
| Feature Complexity | Typical Phases | Default Phase Modifier |
|---|---|---|
| Simple | 1-2 | lean or leanest |
| Medium | 2-4 | lean or normal |
| Complex | 4-8 | normal or full |
| Very Complex | 8+ | full (critical phases) |
Each phase MUST:
hard: Phase cannot start until dependency completessoft: Phase benefits from dependency but can proceed with stubsWhen generating o_spec_config for each phase, use this mapping:
| estimated_complexity | o_spec_config.modifier | o_spec_config.skip |
|---|---|---|
| trivial | leanest | ["TEST", "DOCUMENT"] |
| low | leanest | [] |
| medium | lean | [] |
| high | normal | [] |
| critical | full | [] |
The o_spec_config.model field is optional; leave null unless specific model override is needed for the phase.
Bundling reduces orchestration overhead by combining related phases into single /mux-ospec cycles.
| estimated_complexity | score | bundleable |
|---|---|---|
| trivial | 1 | yes |
| low | 2 | yes |
| medium | 3 | yes |
| high | N/A | no (standalone) |
| critical | N/A | no (standalone) |
Phases CAN be bundled when ALL conditions are met:
execution_order batch (no cross-dependency bundling)Cluster bundleable phases by:
For bundled phases, compute aggregate bundle_config:
modifier: MAX(phase modifiers) - leanest < lean < normal < fullskip: INTERSECTION(phase skips) - if any phase needs a stage, bundle runs itmodel: First non-null model, or nullFOR each batch in execution_order:
1. Separate high/critical phases as standalone
2. FOR remaining trivial/low/medium phases:
a. Cluster by semantic similarity (title prefix, scope overlap)
b. FOR each cluster:
- While cumulative_score <= 10 AND phase_count <= 5: add phase
- Assign bundle_id to grouped phases
3. Generate bundle entries with aggregated config
Generate manifest at: outputs/phases/{timestamp}-{feature-slug}/manifest.yml
# Phase Manifest
# Generated by product-manager skill
meta:
feature: "Feature title"
description: "Brief description of overall goal"
created_at: "ISO timestamp"
total_phases: N
estimated_complexity: "low|medium|high|very_high"
phases:
- id: "phase-1"
title: "Short descriptive title"
description: |
What this phase accomplishes.
Why it's a logical unit.
scope:
- "Specific deliverable 1"
- "Specific deliverable 2"
acceptance_criteria:
- "Testable criterion 1"
- "Testable criterion 2"
dependencies: [] # or ["phase-id"]
dependency_type: null # or "hard"|"soft"
spec_prompt: |
Inline prompt for /mux-ospec to execute this phase.
Include specific technical requirements.
o_spec_config:
modifier: "lean" # full | normal | lean | leanest (derived from estimated_complexity)
model: null # opus | sonnet | haiku (optional override)
skip: [] # list of stages to skip, e.g., ["TEST", "DOCUMENT"]
estimated_complexity: "trivial|low|medium|high|critical"
bundle_id: null # Set by bundling algorithm; null = standalone execution
- id: "phase-2"
title: "..."
dependencies: ["phase-1"]
dependency_type: "hard"
# ... rest of fields
execution_order:
# Computed from DAG - phases that can run in parallel grouped together
- parallel: ["phase-1", "phase-3"] # No dependencies, run together
- sequential: ["phase-2"] # Depends on phase-1
- parallel: ["phase-4", "phase-5"] # Both depend on phase-2
validation:
dag_valid: true
no_circular_deps: true
all_phases_reachable: true
bundles:
# Generated by bundling algorithm - groups trivial/low/medium phases
- bundle_id: "bundle-batch1-group1"
phases: ["phase-1", "phase-2"]
bundle_config:
modifier: "lean" # MAX of bundled phase modifiers
model: null
skip: [] # INTERSECTION of bundled phase skips
spec_title: "Auth models and basic utilities"
spec_path: "specs/2025/12/feat/oauth/bundle-001-auth-models.md"
cumulative_score: 4 # Sum of phase complexity scores
- bundle_id: "bundle-batch2-group1"
phases: ["phase-4", "phase-5"]
bundle_config:
modifier: "lean"
model: null
skip: []
spec_title: "Session and RBAC utilities"
spec_path: "specs/2025/12/feat/oauth/bundle-002-session-rbac.md"
cumulative_score: 5
Read input -> Extract requirements -> Identify components -> List concerns
For each concern:
For each atomic unit:
- What must exist before this works?
- What does this enable?
- Can this run in parallel with anything?
Combine atoms into phases when:
# Pseudocode for validation
def validate_dag(phases):
visited = set()
in_progress = set()
def has_cycle(phase_id):
if phase_id in in_progress:
return True # Cycle detected
if phase_id in visited:
return False
in_progress.add(phase_id)
for dep in phases[phase_id].dependencies:
if has_cycle(dep):
return True
in_progress.remove(phase_id)
visited.add(phase_id)
return False
for phase_id in phases:
if has_cycle(phase_id):
raise ValueError(f"Circular dependency detected: {phase_id}")
After DAG validation, compute phase bundles:
# Pseudocode for bundle computation
COMPLEXITY_SCORES = {"trivial": 1, "low": 2, "medium": 3}
MAX_BUNDLE_SCORE = 10
MAX_BUNDLE_SIZE = 5
def compute_bundles(phases, execution_order):
bundles = []
for batch in execution_order:
batch_phases = [p for p in phases if p.id in batch.phases]
# Separate standalone (high/critical) from bundleable
standalone = [p for p in batch_phases if p.estimated_complexity in ("high", "critical")]
bundleable = [p for p in batch_phases if p.estimated_complexity not in ("high", "critical")]
# Cluster bundleable by semantic similarity (title prefix, scope overlap)
clusters = cluster_by_similarity(bundleable)
for cluster in clusters:
# Create bundles respecting size limits
bundle = create_bundle_from_cluster(cluster, MAX_BUNDLE_SCORE, MAX_BUNDLE_SIZE)
bundles.append(bundle)
return bundles
Compute topological sort with parallelization:
Input: "Add user authentication with OAuth2, session management, and role-based access control"
Output Phases:
phase-auth-models (no deps)
phase-oauth-provider (no deps, parallel with 1)
phase-auth-flow (deps: phase-auth-models, phase-oauth-provider)
phase-rbac (deps: phase-auth-models)
phase-integration (deps: phase-auth-flow, phase-rbac)
Invoke when:
/mux-ospec cyclesOutput is consumed by /mux-ospec command for orchestrated execution.