What is CCPM?
CCPM is a spec-driven project management workflow for AI coding agents, published by Automaze under the MIT license at automazeio/ccpm on GitHub. It takes a feature from an idea to a product requirements document (PRD), from the PRD to a technical epic, from the epic to numbered task files, and from those files to GitHub issues: one epic issue with one sub-issue per task. Each issue is then split into streams that several agents implement at the same time in a dedicated Git worktree, with progress posted back as issue comments. The repository was created on August 18, 2025.
The name comes from Claude Code PM, the original project, and the skill file still expands it as Claude Code Project Manager. Version 1 was a set of Claude Code slash commands in a /pm:* namespace, copied into a project by an installer script. On March 18, 2026 the project was relaunched as v2: a standard Agent Skill that, according to the README, works with Claude Code, Codex, OpenCode, Factory, Amp, Cursor and other harnesses that support Agent Skills. The slash command system is kept on the v1 branch, which is marked as archived and no longer maintained.
There are no GitHub releases or Git tags, so the version shown here is the default branch. The latest commit, 0bcfabb of November 4, 2026, fixed epic sync (empty issue bodies on GNU sed, sub-issue linking, safe re-runs after an interruption) and made the next, standup, blocked and validate scripts dependency-aware. The same day added a database guide and the optional neon-branch.sh script. A funding.json file from October 2026 states that development had slowed after March 2026 and proposes a maintenance plan with quarterly tagged releases.
skill/ccpm/ holds SKILL.md, which detects project management intent in plain language and routes to five reference files (plan, structure, sync, execute, track) plus a conventions file, and 16 Bash files: the 15 scripts the README counts plus a shared lib.sh. Status, standup, search and validation run as scripts; the model writes PRDs, analyses streams and launches agents. Project state is Markdown with YAML frontmatter in the project's .claude/ folder, and GitHub Issues, reached through the gh CLI, is the shared remote state. The GitHub Projects API is not used.
Automaze Ltd states its headquarters in London; its website describes a CTO-as-a-service offering and names Ran Aroussi as founder. The README lists Neon as a supporter. CCPM has no hosted service or user interface, and GitHub is the only tracker it syncs with; the changelog lists GitLab and Linear as researched, not built. Similar projects on iThub include Superpowers and Claude Forge, while Emdash and Orca are desktop apps that run coding agents in parallel Git worktrees.
Key capabilities
- Guided PRD writing Before anything is written, the plan reference has the agent ask about the problem, the affected users, what success looks like, what is out of scope and the constraints. The result is
.claude/prds/<name>.mdwith fixed sections from executive summary to dependencies. Quality gates forbid placeholder text and require user stories with acceptance criteria, measurable success criteria and an explicit out-of-scope list; feature names must be kebab-case. - PRD to technical epic Parsing a PRD produces
.claude/epics/<name>/epic.mdwith architecture decisions, a technical approach split into frontend, backend and infrastructure, an implementation strategy and a task breakdown preview. The epic links back to its PRD in frontmatter. The instructions aim for 10 tasks or fewer per epic. - Task files with dependency metadata Decomposition writes numbered files (
001.md,002.mdand so on) with a description, acceptance criteria, an XS to XL size, an hour estimate and a definition of done. Three frontmatter fields control scheduling:depends_on,parallelandconflicts_withfor tasks that touch the same files. Circular dependencies are treated as an error, and large epics are decomposed by up to five agents at once. - GitHub sync with sub-issues Sync creates an epic issue labelled
epic,epic:<name>andfeature, then one issue per task labelledtaskandepic:<name>. With the gh-sub-issue extension the tasks become sub-issues of the epic; without it the README says CCPM falls back to task lists. Local files are renamed to their issue numbers and agithub-mapping.mdindex is written. Already synced files are skipped, so an interrupted sync can be repeated. - One worktree and branch per epic After sync the agent creates branch
epic/<name>from an up-to-date main and a worktree at../epic-<name>/next to the project root. Commits inside an epic use the formatIssue #N: description, and the conventions forbid--forcein any Git operation. - Parallel stream analysis Before an issue is started, CCPM writes
<N>-analysis.md, which splits the work into streams such as database, service, API, UI and tests. Each stream lists its scope, files, start condition, hours and dependencies, plus shared files, conflict risk and a parallelization factor from 1 to 5. - Parallel agent launch Starting an issue launches one agent per stream that can begin immediately, each limited to its own files and told to commit often and record progress in
updates/<N>/stream-X.md. The issue is assigned to the current GitHub user and labelledin-progress; streams with unmet dependencies are queued and launched later. Conflicts are never resolved automatically: an agent reports them and pauses. The execute reference phrases the launch as a Task call to a general-purpose subagent. - Whole-epic execution Starting a full epic sorts every task into ready, blocked, in progress or complete, analyses ready tasks that have no analysis yet and launches agents for them. Tasks marked
parallel: falseor listed in each other'sconflicts_withare not run together, and anexecution-status.mdfile lists active and queued work. Uncommitted changes block the start. - Progress comments on issues Issue sync posts a comment with completed work, work in progress, technical notes, acceptance criteria status, next steps and blockers, built from the local progress files. A
last_syncfield and a sync marker prevent duplicate comments, and the agent asks for confirmation when the last sync is less than five minutes old. - Closing issues and merging epics Closing a task updates its file, comments on and closes the GitHub issue, ticks the task in the epic issue body and recalculates epic progress. Merging an epic runs the project's detected test command (for example
npm test,pytest,cargo testorgo test), merges the epic branch into main with--no-ff, pushes, removes the worktree and branch, moves the epic to.claude/epics/archived/and closes the epic issue. - Bug reports linked to their issue Added in March 2026: when testing reveals a bug in an issue, CCPM creates a bug task file with a
bug_forfield and a GitHub issue labelledbugwhose body starts with a follow-up reference to the original issue, so GitHub links the two. - Script-first tracking The skill maps 14 operations to Bash scripts: status, standup, epic list, epic details, epic status, PRD list, PRD status, search, in progress, next, blocked, validate, and the create and cleanup modes of
neon-branch.sh. The README describes these as running without model token cost.next.shandstandup.shhold back tasks whose dependencies are still open or that conflict with work in progress. - State validation
validate.shchecks frontmatter consistency on PRDs, epics and tasks, orphaned files, missing GitHub links, dependency integrity andconflicts_withreferences, and exits with status 1 when it finds errors. - Project initialization init.sh checks for the GitHub CLI and installs it with Homebrew or apt-get when missing, runs
gh auth loginif needed, installs theyahsan2/gh-sub-issueextension, creates.claude/prds,epics,rules,agentsandscripts/pm, createsepicandtasklabels and writes a starterCLAUDE.mdif none exists. Its closing hints andhelp.shstill print the v1/pm:*command names. Before any GitHub write, the skill stops iforiginstill points toautomazeio/ccpm. - Optional database branches with Neon
neon-branch.shcreates a Neon branchepic/<name>for an epic and, with--issue, a child branch per writing issue, writesDATABASE_URLandDATABASE_URL_UNPOOLEDinto the worktree's env file, adds env patterns to.gitignoreand deletes the branches on merge. It needs the Neon CLI, Node.js 20.19 or newer andNEON_PROJECT_ID, and exits without changes when they are missing. The guide also describes the same setup with one Postgres database, schema or container per writer. - Installation per harness The README install is a
git cloneof the repository. For Claude Code,skill/ccpmis symlinked or copied to.claude/skills/ccpmin the project; for Factory it is symlinked to~/.factory/skills/ccpm; other Agent Skills harnesses are pointed atskill/ccpm/. Prerequisites aregit, an authenticatedghCLI and a GitHub repository for the project. The scripts are Bash, and the changelog records that Windows needs a POSIX shell. - Archived v1 slash commands The v1 branch contains 38 command files in the
/pm:*namespace, among themprd-new,prd-parse,epic-decompose,epic-sync,epic-oneshot,issue-analyze,issue-start,issue-sync,next,standup,syncandimport, plus/context:*and/testing:*commands, four agents and 11 rule files. Its README installs it withcurl -sSL https://automaze.io/ccpm/install | bash; the installer script clones the repository into the current folder and deletes its.gitdirectory. - Project-reported results The README states that teams using CCPM report 89% less time lost to context switching, 5 to 8 parallel tasks instead of 1, 75% fewer bugs and up to 3 times faster delivery. Its eval table shows CCPM-equipped agents passing 100% of PRD creation, issue execution and standup checks against 27.7% without the skill. The underlying eval runs are not published.
Where CCPM fits
Planning a feature before code is written
A request such as "I want to build a notification system" starts the plan phase. The agent asks clarifying questions, writes the PRD to .claude/prds/ and offers to parse it into a technical epic. PRD and epic are ordinary Markdown files in the repository, so they can be edited, reviewed and committed like code. Planning, epic writing and decomposition work locally without GitHub; the README's local versus remote table lists GitHub only for task breakdown and progress updates on sync and for final deliverables.
Turning an epic into a shared GitHub backlog
After decomposition, "sync the notification-system epic to GitHub" creates the epic issue, one sub-issue per task with labels, renames the task files to issue numbers and sets up the epic worktree. The README presents GitHub Issues as the single source of truth for a team: agents and people can pick up the same issues, progress appears as issue comments, and existing labels, milestones and pull request workflows stay in use. A GitHub Projects board is not required.
Running several agents on one issue
"Start working on issue 42" first analyses the issue into streams, for example database migrations, service logic, API endpoints, UI and tests, then launches one agent per stream in the epic worktree. Each agent is restricted to its files, commits with the issue number and writes progress to its own stream file, while the main conversation coordinates. The README illustrates this with five agents splitting a user authentication issue and a table comparing serial and parallel wall time.
Standups and status from project files
Questions such as "standup", "what's next" or "what's blocked" are answered by running the Bash scripts against .claude/epics/ rather than by the model. The standup lists work completed, work in progress and blockers; next.sh shows open tasks whose dependencies are closed and that do not conflict with active work; validate.sh reports inconsistent frontmatter, orphaned files and broken dependency references.
Closing tasks, handling bugs and merging an epic
"Close issue N" updates the local file and the GitHub issue and recalculates epic progress. A bug found while testing an issue becomes its own linked bug task and issue. "Merge the X epic" refuses to run with uncommitted changes in the worktree, warns about open tasks, runs the project's tests, merges the epic branch into main, cleans up the worktree and branch, archives the epic folder and closes the epic issue.
Separate databases for parallel agents
Worktrees separate files but not data: agents in one worktree share its .env and therefore one database. The database guide maps one database to each epic and one more to each task that writes while another writer is active, and makes schema changes a sequential task that others depend on. With Neon configured, epic sync and merge create and delete the branches automatically; without Neon the guide describes equivalent setups with separate Postgres databases, schemas or containers.
Install
git clone https://github.com/automazeio/ccpm.git, then in the project root: ln -s /path/to/ccpm/skill/ccpm .claude/skills/ccpmReviews of CCPM
Be the first to share your experience with CCPM.
Write a review
Loading review form…
Found CCPM useful? Upvote it todayYour vote helps other IT teams find it in the daily ranking.






