Claude Code PM from Automaze is a pragmatic workflow for turning product specs into epics, GitHub issues, and ultimately production-grade code, all with full traceability. The repository documents a clean, repeatable way to preserve context, split work for parallel execution, and keep human and AI contributors in sync using GitHub Issues as the shared source of truth.
automazeio
Organization
ccpm
Project management system for Claude Code using GitHub Issues and Git worktrees for parallel agent execution.The problem and a grounded solution
Most AI-assisted coding still happens in private sandboxes. Context disappears between sessions, parallel tasks collide, and progress is hard to see until a pull request materializes.
Claude Code PM addresses this with a spec-first, discipline-driven approach: write the requirements, translate them into a technical epic, decompose into tasks, and synchronize those tasks to GitHub where the whole team can track work.
The trick is the separation of concerns. Local agents handle heavy lifting in isolated threads, while GitHub remains a tidy, auditable log of what is planned and what is done. The README.md lays out the phases, commands, and architecture clearly.
Key features
- Spec-driven phases: PRD to epic to tasks to code, with explicit traceability at each step (see the flow in README.md).
- GitHub-native sync: Issues and sub-issues model the work; comments are the audit trail. The system integrates cleanly with GitHub workflows and tooling (GitHub Docs, 2025).
- Parallel agents: Use agents as context firewalls to run multiple work streams in parallel and return concise summaries (AGENTS.md).
- Command library: A clear command set for PRDs, epics, issues, and sync operations, including one-shot flows to get moving fast (COMMANDS.md).
- Worktree isolation: Use Git worktrees to keep parallel edits conflict-free while converging to a single clean merge in the end (see architecture notes in README.md).
Why I like it
Two details stand out. First, it embraces GitHub Issues as the canonical database. That makes human-AI handoffs natural: you can start an issue with an agent and have a teammate finish it, and the trail of updates is visible to everyone.
Second, the system leans into parallelism without chaos by using isolated worktrees and specialized agents that summarize their work back to the main thread.
The AGENTS.md guidance focuses on context reduction rather than anthropomorphizing agents, which keeps conversations crisp and decisions reversible.
# Plan and ship an end-to-end feature with PM commands
/pm:prd-new memory-system
/pm:prd-parse memory-system
/pm:epic-oneshot memory-system
/pm:issue-start 1234
/pm:issue-sync 1234
Under the hood
The repository is intentionally lightweight. It provides a portable protocol for working with Claude Code: a ruleset, a command catalog, and a directory layout that preserves context.
The project structure centers on the .claude/ directory, which houses always-on instructions, agent definitions, command files, and local state for epics and PRDs. The .claude/ layout spelled out in the System Architecture section makes it easy to pick up and apply to any codebase.
Agents are a core idea here. Rather than stuffing every detail into a single conversation, specialized agents do the heavy reading, testing, or code changes and then return only the essentials. The philosophy is documented in AGENTS.md, which stresses context reduction, single-purpose design, and a coordinator pattern for parallel work.
On the integration side, GitHub Issues carries the project state, and for parent-child relationships the readme recommends the gh-sub-issue CLI extension. For a primer on GitHub sub-issues and dependencies, see GitHub Issues docs (GitHub Docs, 2025).
Although the repo itself is not a heavy codebase, it fits neatly into modern agent-tooling stacks. If you are using the Model Context Protocol to standardize tool access across AI apps, this approach snaps into place because the boundaries between planning, execution, and synchronization are explicit (MCP, 2025).
Use cases
Feature delivery with parallel streams is the obvious first stop: an epic like user authentication can split into schema, services, API, UI, and tests, each handled by a specialized agent and merged cleanly.
The same flow works for documentation sprints, bug bashes, and refactor campaigns: open an epic, decompose into tasks, and let the team or agents fan out without losing the thread. Because GitHub Issues act as the single source of truth, managers do not need separate dashboards to see meaningful progress.
Another practical use case is onboarding. By recording PRDs, epics, and decisions in the .claude/ structure and synchronizing to issues, new team members can reconstruct the why and the how without spelunking through chat logs. For remote or global teams, that built-in transparency is worth its weight in time zones.
Community and contribution
This is an MIT-licensed, open repository that invites teams to adapt the workflow to their own needs. While there is no dedicated CONTRIBUTING.md at the time of writing, the documentation in README.md, COMMANDS.md, and AGENTS.md is clear enough to get started. Feedback and improvements via issues and pull requests are the natural path.
Usage and license terms
The project uses the MIT License. In short: you can use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software, provided you include the copyright and license notice. The software is provided as-is, without warranty. See LICENSE for the full text.
Impact and where it could go
As teams adopt agentic workflows, the bottleneck is rarely raw generation. It is coordination, context, and confidence. Claude Code PM tackles these head-on by making planning explicit, collaboration native to GitHub, and parallelism a first-class capability.
I expect to see deeper integrations with CI, richer status dashboards, and tighter connections to MCP-based tools over time. Even as-is, the system lowers risk by making the pathway from idea to code inspectable at every step.
About Automaze
Automaze is a CTO-as-a-Service partner that helps founders ship products without giving up equity. Their offering spans architecture, design, coding, AI/ML, devops, and product guidance on a predictable monthly plan. The site outlines membership benefits, scope, and team background, and includes options for ad-hoc syncs and scaling support as you grow. Learn more at automaze.io.
Conclusion
If you want your AI-assisted development to be collaborative, auditable, and resilient to context loss, this repository is a solid blueprint. Start by reading the README, skim the commands and agents, and then try the PRD-to-epic-to-issues flow on a small feature. Keep GitHub as your single source of truth, and let parallel agents do the heavy lifting while you stay focused on outcomes.
Claude Code PM: Shipping Better Software with Spec-driven, Parallel Workflows