ccpm

Enforces a five-phase workflow (Brainstorm → PRD → Epic → Task → Code) where every line of code traces back to a specification document stored in .claude/prd/ directory. Uses GitHub Issues as the single source of truth and coordinates phase transitions through structured commands that validate completeness before advancing. Prevents context loss by maintaining explicit traceability between requirements and implementation artifacts.

Deploys multiple specialized AI agents in parallel by creating isolated Git worktrees for each Task/Issue, preventing merge conflicts and context pollution. Each agent operates independently on its worktree while the main thread maintains strategic oversight. Uses Git worktree branching strategy to enable true parallelism without agents interfering with each other's work or context windows.

Implements workflow enforcement through structured commands (pm init, pm prd, pm epic, pm task, pm code) that validate phase completion before advancing. Each command checks preconditions (e.g., PRD must exist before creating Epics), updates GitHub Issues and .claude/ state, and provides feedback on workflow progress. Commands are the primary interface to the system, ensuring users follow the five-phase discipline rather than ad-hoc development.

Optimizes context window usage by delegating implementation details to specialized agents while keeping the main orchestration thread clean and strategic. The main thread maintains oversight of Epic progress without drowning in code details; each agent handles isolated context for its Task. This prevents context window exhaustion that typically occurs when a single agent tries to manage multiple files and implementation details simultaneously.

Uses GitHub Issues as the distributed database and coordination layer for all project state: PRDs, Epics, Tasks, and agent assignments. Each Issue contains structured metadata (labels, assignees, linked issues) that agents read to understand task context and dependencies. Synchronization between local .claude/ directory and GitHub Issues enables team collaboration while maintaining local development efficiency through bidirectional updates.

Deploys different agent types (Parallel Worker, Test Runner, Code Reviewer) based on task requirements, with each agent type optimized for specific work patterns. Agents are assigned to GitHub Issues through labels and metadata, and the system routes tasks to the appropriate agent based on task type (implementation, testing, review). Each agent type has its own context strategy and execution model optimized for its domain.

Decomposes Epics into multiple independent Tasks that can execute in parallel, with explicit dependency tracking through GitHub Issue relationships. The system identifies task boundaries that allow parallelization while respecting dependencies (e.g., database schema tasks must complete before ORM tasks). Uses GitHub linked issues to represent dependencies, enabling agents to understand task ordering and blocking relationships.

Generates agent prompts that include task specification, acceptance criteria, relevant code context, and role-specific constraints (e.g., 'do not modify database schema' for ORM implementation). Prompts are constructed from GitHub Issue metadata, linked code files, and agent role templates, ensuring agents have sufficient context without context window pollution. Uses a context-preservation strategy where implementation details are delegated to specialized agents while the main thread stays strategic.

Integrates a Test Runner agent that executes tests within the task workflow, validating code changes against acceptance criteria before merging. Tests are defined in the task specification and executed in the isolated worktree, with results reported back to GitHub Issues. The system treats testing as a first-class workflow phase, not an afterthought, with dedicated agent role and context strategy optimized for test execution and debugging.

Deploys a Code Review agent that analyzes code changes against acceptance criteria, architectural patterns, and code quality standards before merge. The review agent operates on the completed worktree, examining diffs and providing structured feedback through GitHub Issues. Review is treated as a distinct workflow phase with its own agent role, context strategy, and success criteria, enabling systematic code quality enforcement.

Maintains a local .claude/ directory structure that mirrors GitHub Issues state, enabling offline access and fast agent queries without repeated API calls. The directory contains PRDs, Epics, Tasks, agent configurations, and context files organized hierarchically. Synchronization between local state and GitHub Issues is bidirectional: local changes are pushed to GitHub, and GitHub updates are pulled locally, with conflict resolution through timestamps and manual intervention.

Implements a three-level hierarchical decomposition where PRDs are decomposed into Epics, Epics into Tasks, with explicit parent-child relationships maintained through GitHub Issue linking. Each level has specific artifacts and success criteria: PRDs define product vision, Epics define feature scope, Tasks define implementation work. Traceability is maintained through linked issues, enabling navigation from code back to original PRD requirement.