Goal-Backward Phase Management

The orchestration problem emerges when phases accumulate context while losing coherence. Development workflows that chain tasks sequentially hit predictable failure modes: context windows bloat with irrelevant history, requirements drift from original goals, and incomplete milestones cascade forward as technical debt. The solution requires inverting the planning direction and segmenting execution context.

Goal-backward planning addresses the core issue where forward-thinking tasks rarely achieve intended outcomes. Instead of asking “what should I do next,” the pattern starts with “what must be true for success” and works backward to generate tasks that ensure those conditions. This prevents building elegant solutions to the wrong problems.

Phase verification creates deterministic validation checkpoints that catch incomplete work before it propagates. Rather than hoping each phase completes correctly, systematic auditing ensures requirements were actually implemented, not just attempted. The pattern treats phase completion as a binary state requiring evidence, not assumption.

Fresh context execution prevents the accumulated noise that degrades decision quality over long sessions. Each task spawns in clean subagent context with only relevant information, maintaining execution clarity while the main orchestrator tracks overall progress. This architectural split preserves both detail focus and strategic continuity.

CLAUDE.md Configuration

The planning and verification patterns require explicit constraints on how goals get decomposed and validated:

Add goal-backward planning requirement:

When planning any phase or task, first explicitly state: 1) What the end goal is, 2) What must be true for that goal to be achieved, 3) Then work backwards to create tasks that ensure those conditions are met. Always plan backward from the desired outcome, not forward from current state.

This constraint forces explicit goal articulation before task generation. Without backward planning, tasks emerge from current capabilities rather than required outcomes, leading to feature creep and scope drift.

Add commit automation instruction:

Automatically commit work at logical breakpoints (after completing a task, fixing a bug, adding a feature) with descriptive commit messages that include what was accomplished and why. Never ask me to commit manually - handle git operations automatically as part of the workflow.

Manual commit management interrupts development flow while adding no decision value. Automated commits at logical breakpoints create project history without cognitive overhead.

Subagent Creation

Phase management requires specialized agents that handle verification and execution isolation:

Create phase verification subagent:

Input: Completed phase description + original requirements. Process: Run deterministic validation against phase goals, identify missing implementations, generate specific fix plans for gaps. Output: Binary completion status + fix plan for any missing items.

The subagent prevents incomplete phases from advancing by treating completion as measurable rather than subjective. Standard workflow assumes phases complete correctly; this pattern requires proof through systematic checking.

Skills to Create

Create milestone completion skill:

The skill ensures project milestones achieve actual completion rather than apparent completion. First, it audits all requirements against implemented functionality. Second, it identifies specific gaps between planned and actual outcomes. Third, it generates targeted fix plans for missing items. Fourth, it only marks milestones complete when verification passes.

This skill transforms milestone tracking from progress reporting to quality gates. Without systematic auditing, milestones become arbitrary dates rather than validated achievements.

Slash Commands for Orchestration

Create /debug-with-agent command:

Stage 1 captures symptoms and context. Stage 2 spawns debugging subagent with hypothesis generation framework. Stage 3 routes investigation tasks to subagent for systematic analysis. Stage 4 returns specific fix recommendations rather than general troubleshooting advice.

Debugging complexity pollutes main context with investigation noise. Specialized debugging agents isolate investigation work while maintaining systematic approaches to problem resolution.

Create /parallel-execution command:

Stage 1 analyzes planned tasks for dependency relationships. Stage 2 identifies tasks that can run independently. Stage 3 spawns multiple subagents for parallel work. Stage 4 coordinates completion and manages dependent task sequencing.

Sequential execution wastes time when tasks have no interdependencies. Parallel execution through coordinated subagents reduces overall completion time while maintaining proper sequencing for dependent work.

Workflow Patterns

For multi-task execution:

Fresh context per task prevents accumulated noise degradation. Route each task to dedicated subagent with minimal relevant context. Log task completion and results in main orchestrator. Maintain strategic continuity while preserving execution clarity.

For UI verification:

Systematic checkpoints require human validation for visual behavior. Route implementation to subagent, automatically build/open application, present specific verification questions about functionality, block progression until human confirms expected behavior.

The synthesis reveals the tension between systematic validation and execution speed. Goal-backward planning and phase verification slow initial progress by requiring explicit goal articulation and completion proof. Fresh context execution and parallel processing accelerate later stages through cleaner decision-making and coordinated work distribution. The pattern trades upfront planning overhead for backend execution reliability, preventing the common failure mode where fast starts lead to incomplete deliverables requiring extensive rework.