CCPM: Spec-Driven Project Management for AI Coding Agents

Why AI Agents Lose Context Between Sessions

Most AI coding workflows carry a structural flaw: project state lives in the chat window. When a session closes, the record of what was decided, why a particular architecture was chosen, and which tasks were in flight disappears. The next session starts from nothing, rediscovering decisions that were already made and documented nowhere except the conversation history.

CCPM addresses this by moving project state out of chat and into files and GitHub Issues. The project targets engineers using AI coding tools like Claude Code, Codex, Cursor, Amp, or Factory who are building features complex enough to span multiple sessions or multiple agents. The README frames its core problems as context evaporation between sessions, parallel work creating conflicts when multiple agents touch the same code, requirements drifting as verbal decisions override written specs, and progress becoming invisible until the very end.

Those four problems map to three mechanisms: files in `.claude/epics/` that preserve project state across sessions, Git worktrees that let agents work in parallel on independent tasks, and a required PRD-to-issue traceability chain that prevents undocumented architectural decisions.

The Five Phases from Brainstorm to Track

CCPM enforces a fixed sequence before any code gets written. The README names the phases as Brainstorm, Document, Plan, Execute, and Track.

In the Brainstorm phase the agent guides deeper thinking about requirements than a simple feature description produces. Document turns that thinking into a PRD that leaves nothing open to interpretation. Plan translates the PRD into epics, then breaks each epic into discrete tasks with explicit technical decisions and dependency annotations. Execute instructs agents to build exactly what the plan specifies. Track maintains status through GitHub Issue comments and worktree commits.

The discipline exists because CCPM's stated principle is that every line of code must trace back to a specification. An agent that skips the Document phase and writes code from a vague request is doing what the README calls "vibe coding," and the skill is designed to block that pattern by requiring each phase to produce a persistent artifact before the next begins.

In practice, the first step for any new feature is a planning conversation with the agent, not a coding instruction. Developers accustomed to giving direct coding prompts will need to adjust their workflow before they see the benefit. The overhead is intentional: CCPM trades speed of starting for completeness of documentation.

Parallel Execution with Git Worktrees

The most concrete capability in the README is the worktree-based parallel execution model. A single GitHub Issue can be decomposed into independent task streams, each running in its own worktree so agents never conflict over the same working directory.

The README illustrates this with an example. An issue named "Implement user authentication" breaks into five parallel streams: database tables and migrations, service layer and business logic, API endpoints and middleware, UI components and forms, and test suites and documentation. In a serial model all five run sequentially. In CCPM's parallel model they run simultaneously, with the README claiming a wall time reduction to one-fifth compared to serial execution.

Each agent reads task details from `.claude/epics/` and commits progress back through Git. The main conversation acts as the conductor, receiving status updates without accumulating implementation detail. Tasks must be tagged `parallel: true` in the task files to run concurrently; tasks with unresolved dependencies on other running streams must wait.

The pattern only holds if the parallel streams genuinely do not share code paths. If two agents need to edit the same file simultaneously the worktree isolation breaks down, and the conflict problem CCPM was designed to solve reappears. Decomposing a task so the streams are truly independent requires careful planning during the Plan phase.

Installing CCPM in Claude Code and Other Harnesses

CCPM is a standard agent skill following the agentskills.io open standard. The prerequisites are `git` and the `gh` CLI, with the `gh` CLI authenticated via `gh auth login`, and a GitHub repository for the project.

Clone the repository first:

git clone https://github.com/automazeio/ccpm.git

For Claude Code, create a `skills/` directory in the project root and symlink the skill:

ln -s /path/to/ccpm/skill/ccpm .claude/skills/ccpm

For Factory or Droid, the target is the user-level skills directory:

ln -s /path/to/ccpm/skill/ccpm ~/.factory/skills/ccpm

For any other harness that follows the agentskills.io standard, point it at `skill/ccpm/` inside the cloned repository. After that, CCPM activates automatically when the agent detects project-management intent in natural language. No special syntax is required to trigger the workflow.

The README notes that deterministic operations such as status checks, standup reports, search, and validation run as bash scripts rather than through the language model. This design keeps those operations fast and avoids token costs for work that does not require reasoning.

Where CCPM Does Not Fit

The five-phase discipline is the right tool for complex, multi-session work and the wrong tool for most other scenarios. Writing a PRD before touching code adds significant time when the task is small, when the requirement is already clear, or when the goal is exploratory. Teams that prototype first and specify after the fact will find the workflow inverted.

The GitHub dependency is hard. Issue state is project state under the CCPM model, and the sync commands that create epics and sub-issues require an authenticated `gh` CLI. A team without a GitHub repository, or one using a different issue tracker, cannot use the workflow as documented. The README gives no alternative path.

The last push to the repository was on 2026-03-18. Whether the skill continues to work with harnesses that have since updated their own specs and hook systems is something each adopter would need to verify by testing. The README references no GitHub releases for the project, so there is no formal changelog to consult.

The agentskills.io standard that CCPM implements is defined and maintained outside this repository. If that standard changes in a way that breaks backward compatibility, CCPM would need an update to remain functional.

CCPM Versus Direct Prompting and Other Task Tools

The alternative to CCPM is giving agents prompts directly and tracking progress in chat or in ad hoc documents. The practical difference is persistence and traceability. With direct prompting, context lives in the conversation. A closed session loses the context unless it was explicitly saved. CCPM stores project state in `.claude/epics/` and in GitHub Issues, where it persists indefinitely and is readable by any harness in any session.

A common tool for structured task management on engineering teams is Linear, a commercial issue-tracking SaaS that provides a web interface, team-level automation, and API access. Linear is designed for human collaboration on software projects. CCPM uses GitHub Issues specifically to avoid introducing a dependency on a separate project management service; it works with tools most developers already have, at the cost of a less polished interface.

For teams already using GitHub and already running an AI coding harness, CCPM's zero-new-tool approach is its clearest advantage. The tradeoff is that the entire project management interface is the agent conversation itself, which is less accessible to non-engineering stakeholders than a dedicated tool.

Licensing and Project Status

CCPM is released under the MIT licence, which permits commercial and non-commercial use, modification, and redistribution with no restrictions beyond attribution. The project homepage is automaze.io. The agentskills.io standard that CCPM implements is documented at agentskills.io.

The repository has no GitHub releases, meaning there is no versioned distribution and no formal changelog. The last push was on 2026-03-18. Any changes since that date would require watching the master branch directly. For production use, pinning to a specific commit hash would give more predictable behavior than tracking the default branch.

Editorial conclusion

CCPM makes sense for developers who regularly lose track of decisions between AI sessions, or who want to run multiple agents on a project in parallel without manually managing conflicts. Those working on single-session scripts or prototyping without GitHub will find the five-phase overhead disproportionate to their needs. Before adopting it, confirm your harness follows the agentskills.io standard and that you have the gh CLI authenticated against a GitHub repository. Without those two prerequisites, the sync commands that create epics and sub-issues will not run. The last push to the repository was on 2026-03-18.

Frequently asked questions

Official sources

1. automazeio/ccpm on GitHub
2. Issues
3. License: MIT
4. Project website
5. README