If you've tried to build anything substantial with AI agents, you know the pain. You start strong, but three days later you're explaining the same context for the fifth time, your parallel work is stepping on its own toes, and nobody knows what's actually done until someone brave enough opens that 47-file PR.

We built CCPM (Claude Code Project Management) to fix this. It's a lightweight project management system that keeps AI agents on track by treating GitHub Issues as your source of truth and making every line of code traceable back to a spec.

The Problem Nobody Talks About

Here's what actually happens when you try to build with AI agents today:

Monday: "Let's build a caching system!" Tuesday: "Wait, why are we using Redis again?" Wednesday: "Who decided on this architecture?" Thursday: "These two agents just rewrote each other's work" Friday: "I have no idea what's actually done"

Sound familiar? The issue isn't the AI. It's that most AI development happens in isolation: a single developer, working with Claude in their local environment, with progress trapped in chat logs. When you try to scale this up, everything falls apart.

Breaking AI Development Out of Its Silo

CCPM does something different: it makes AI development visible to your entire team. By using GitHub Issues as the backbone, we get:

True team collaboration. Multiple Claude instances can work on the same project simultaneously. Your human teammates see AI progress in real-time through issue comments. No more "what did the AI do?" meetings.

Seamless handoffs. An AI agent can start a task, a human developer can finish it, another AI can write the tests. The context travels with the issue, not trapped in someone's chat history.

Scale that actually works. Add team members without onboarding friction. Run multiple AI agents in parallel on different issues. Your distributed team stays synchronized automatically, using the GitHub workflows they already know.

This isn't just project management. It's a collaboration protocol that lets humans and AI agents work together using infrastructure your team already trusts.

No More Vibe Coding

Here's our core principle: every line of code must trace back to a specification.

We enforce a strict discipline:

  1. Brainstorm thoroughly before touching code
  2. Document requirements that leave nothing to interpretation
  3. Plan with explicit technical decisions
  4. Execute exactly to spec
  5. Track progress transparently

No shortcuts. No assumptions. No "I think this is what they meant." When an AI agent picks up a task, it knows exactly what to build because the spec says so.

What CCPM Actually Does

CCPM is refreshingly simple: write specs, turn them into GitHub Issues, and let agents work in parallel without conflicts.

Here's the workflow:

  1. Write a real PRD (Product Requirements Document)
  2. Convert it to an epic with technical decisions baked in
  3. Decompose into tasks with clear acceptance criteria
  4. Sync to GitHub as properly linked issues
  5. Execute in parallel without stepping on each other (using Git worktrees)

The magic is that everything stays connected. Your implementation traces back to your spec, your commits trace back to your issues, and your issues trace back to your PRD.

A Real Example

Let me show you what this looks like in practice. Say you're building a memory system for your app:

# Start with a proper spec
/pm:prd-new memory-system
# Launches a guided session to capture requirements and constraints

# Convert to technical plan
/pm:prd-parse memory-system
# Creates an epic with architecture decisions

# Ship it to GitHub
/pm:epic-oneshot memory-system
# Creates GitHub issues with proper relationships

# Start working (in parallel!)
/pm:issue-start 1235  # API endpoints
/pm:issue-start 1236  # Frontend components
/pm:issue-start 1237  # Test suite

# Keep everyone informed
/pm:issue-sync 1235
# Updates flow to GitHub as comments

Your whole team can see what's happening. Product managers check issue comments. Developers review PRs tied to specific acceptance criteria. Everything has a paper trail.

Why GitHub Issues? (And Not Another Tool)

We tried everything. Notion, Linear, custom databases. They all created the same problem: a silo between planning and code.

GitHub Issues live where your code lives. They give you:

  • Comments for the audit trail
  • Labels for organization
  • Relationships for dependencies
  • An API everyone already knows
  • Webhooks your tools already use

Plus, when an AI agent updates an issue, your human teammates see it immediately. The single source of truth isn't a concept, it's literally your issue tracker.

The Parallel Execution Secret

Here's something we discovered: most "single" tasks aren't single at all. That "implement auth" ticket? It's actually database changes, API endpoints, frontend components, tests, and documentation.

CCPM recognizes this. Each agent works in its own git worktree:

# These all run simultaneously without conflicts
/pm:issue-start 1235  # Agent 1: API
/pm:issue-start 1236  # Agent 2: Frontend
/pm:issue-start 1237  # Agent 3: Tests

No merge conflicts. No overwritten work. When they're done, you have a clean history with each commit tied to its acceptance criteria.

The Unexpected Benefits

After dogfooding this for a few months, we noticed things we didn't expect:

Onboarding is instant. New team members (human or AI) can read the PRD, check the epic, and understand everything in minutes.

Reviews are actually reviewable. Instead of a massive PR with "implemented stuff," you get targeted commits tied to specific criteria.

The "what were we thinking?" problem disappears. Every weird decision has a paper trail back to its requirement.

Remote teams love it. Async collaboration just works when everything flows through issues.

Some Opinions We Baked In

CCPM makes deliberate choices:

  • Specs aren't optional. No spec, no code. This keeps AI aligned and humans informed.
  • Local-first, sync when ready. Work happens locally, GitHub gets updates when you choose.
  • Issues over Projects. GitHub Projects are fine for visualization, but Issues are the source of truth.
  • Boring tech wins. Shell scripts, markdown, git. Nothing fancy, everything debuggable.

Try It Yourself

Getting started takes about two minutes:

# Clone CCPM into your project
git clone https://github.com/automazeio/ccpm.git .claude/
cd .claude/

# Initialize everything
/pm:init

# Start your first feature
/pm:prd-new your-feature-name

The system walks you through creating your first PRD, decomposing it into tasks, and syncing with GitHub.

What's Next

We're exploring a few directions:

  • Smarter agent specialization for different parts of your stack
  • Better acceptance criteria validation before work begins
  • Automatic PR creation when tasks complete

But honestly, the current version already solves the core problem: keeping AI agents productive without losing your sanity, while letting your whole team see what's happening.

The Bottom Line

CCPM acknowledges a simple truth: AI agents need different workflows than humans, but they need to work together. It's the minimal system that makes this possible.

If you're tired of explaining context repeatedly, watching parallel work collide, or wondering what your AI agents actually accomplished, give CCPM a try. At worst, you'll have better specs. At best, you'll transform how your team ships software.

Check it out at github.com/automazeio/ccpm. The README has everything you need to get started.