The product management toolkit for Claude Code. Built for PMs who code.

20 skills, 5 rules, 5 agents, 4 slash commands. Everything a technical PM needs to ship faster with AI.

# As a Claude Code plugin (recommended)
claude plugin install pm-pilot

# Or clone and configure manually
git clone https://github.com/mshadmanrahman/pm-pilot.git
cd pm-pilot
# Copy skills/rules/agents to your ~/.claude/ directory

• Claude Code installed and working (get it here)
• A terminal (macOS Terminal, iTerm2, Warp, VS Code terminal, etc.)
• An Anthropic API key or Claude Max subscription (you need this for Claude Code itself)

That's it. No Node.js, no Python, no build step. PM Pilot is pure markdown.

# Option A: As a Claude Code plugin (recommended)
claude plugin install pm-pilot

# Option B: Clone and install manually
git clone https://github.com/mshadmanrahman/pm-pilot.git

If you used Option B, copy the pieces to your Claude Code directory:

# Copy skills, rules, agents, and commands to user-level
cp -r pm-pilot/skills/* ~/.claude/skills/
cp -r pm-pilot/rules/* ~/.claude/rules/
cp -r pm-pilot/agents/* ~/.claude/agents/
cp -r pm-pilot/commands/* ~/.claude/commands/

# Create your memory directory
mkdir -p ~/.claude/memory
cp pm-pilot/memory/MEMORY-TEMPLATE.md ~/.claude/memory/MEMORY.md

PM Pilot works best when Claude Code has MCP servers connected. These are the most impactful:

You can add MCP servers in Claude Code settings or via claude mcp add.

No MCP servers? PM Pilot still works. Skills like market-sizing, writing-style, tdd-workflow, and security-review work with zero external connections.

Run the interactive setup wizard:

/configure-pm-pilot

Or configure manually:

1. Set your company name: Edit skills/pm-core/ask-company/SKILL.md and replace [YOUR_COMPANY] in the Configuration section
2. Seed your memory: Open ~/.claude/memory/MEMORY.md and add your current projects and key stakeholders (see examples/memory-example.md for format)
3. Set your writing voice (optional): Run the writing-style skill with 2-3 sample posts

Open Claude Code in any project and try these:

"prep for my meeting with Sarah"          → meeting briefing from Jira/Slack/Calendar
"weekly status"                           → auto-generated accomplishment report
"size the market for AI code assistants"  → TAM/SAM/SOM analysis
"dogfood https://myapp.com"               → systematic QA with bug reports
"/plan"                                   → implementation plan for any feature
"tell me everything about Project X"      → cross-channel research synthesis

The more you use PM Pilot, the smarter it gets:

Day 1:   Memory is empty. You explain your projects.
Day 5:   Memory has your projects, people, preferences. Less explaining.
Day 15:  Memory has your process, lessons, patterns. Almost zero re-explaining.
Day 30:  New sessions start with full context. You just say what to do.

The key is corrections compound. When you correct Claude, it saves a feedback memory. That correction persists forever. You never repeat yourself.

After installing, run the configuration wizard:

/configure-pm-pilot

This will:

1. Detect your available MCP tools (Jira, Slack, Confluence, etc.)
2. Set your company name for the ask-company skill
3. Create your initial MEMORY.md from the template
4. Validate that everything is connected

PM Pilot uses a file-based memory system that compounds learning across sessions:

memory/
  MEMORY.md          # Index file (always loaded, under 200 lines)
  project_*.md       # Project context
  user_*.md          # People context
  feedback_*.md      # Corrections and preferences
  reference_*.md     # Pointers to external systems

The key insight: MEMORY.md is always in context. Every session starts with full knowledge of your projects, people, and preferences. No re-explaining needed.

See examples/ for populated examples.

MORNING
  Open Claude Code → MEMORY.md auto-loaded
  "Continue the matchmaker redesign" → full context from memory
  (or "read the latest handoff" → exact pickup from yesterday)

DURING SESSION
  Work normally
  Corrections saved as feedback memories
  New project info updates memory entries

END OF DAY
  "Create a handoff" → saves decisions + next steps
  Learnings saved to memory → next session starts smarter

PM Pilot optimizes the input side (compressed rules, lazy-loaded skills, structured memory). For the output side, pair it with RTK (Rust Token Killer), which strips noise from tool outputs before they hit context.

brew install rtk
rtk init -g --hook-only

Together: ~50% fewer input tokens + ~70% fewer output tokens. Significantly longer sessions before hitting limits or compaction.

Five compressed rules that load with every message (~600 tokens total):

• coding-style.md - Immutability, file organization, error handling
• git-workflow.md - Conventional commits, PR process
• testing.md - TDD, 80% coverage minimum
• security.md - Pre-commit security checklist
• session-workflow.md - Memory and learning protocol

Edit skills/pm-core/ask-company/SKILL.md and configure:

• Your company name
• Available MCP tools (Confluence, Jira, Slack, etc.)
• Team structure and ownership areas

Run the writing-style skill with 2-3 sample posts to extract your voice profile. The skill stores it and applies it to all future drafts.

Create a new skill directory:

skills/your-skill/SKILL.md

Follow the SKILL.md format from any existing skill as a template.

1. Memory over transcripts. A 200-line MEMORY.md beats a 50K-token session replay.
2. Skills load on demand. 20 skills, zero startup cost.
3. Rules are compressed. 600 tokens, not 6,000.
4. Research before coding. Search first, build second.
5. Every session compounds. Corrections become rules. Patterns become skills.

PRs welcome. To add a skill:

1. Create skills/category/your-skill/SKILL.md
2. Follow the frontmatter format (name, description, origin, version)
3. Include clear triggers, step-by-step procedure, and output format
4. Keep under 200 lines

Skills need a SKILL.md file in their directory. Verify the path:

ls ~/.claude/skills/meeting-prep/SKILL.md

If missing, re-copy from the pm-pilot repo. Restart Claude Code after adding skills.

These skills need MCP servers (Jira, Slack, etc.) to pull data. Check your connected tools:

claude mcp list

If no MCP servers are connected, these skills will tell you what's missing.

MEMORY.md must be in the right location for your project:

• User-level (all projects): ~/.claude/memory/MEMORY.md
• Project-level (one project): .claude/memory/MEMORY.md in your project root

Claude Code automatically loads MEMORY.md from these locations.

PM Pilot's rules use only ~950 tokens. If context is filling up:

1. Use strategic-compact to compact at logical milestones
2. Use handoff-doc to save state, then /clear and resume
3. Offload research to sub-agents with orchestrator

Create a directory under skills/ with a SKILL.md inside:

skills/my-category/my-skill/SKILL.md

Use any existing skill as a template. The frontmatter (name, description, triggers) is what Claude Code uses to match your requests to the right skill.

Open-source tools for PMs who ship with AI:

MIT

Built by a PM, for PMs. Pure markdown, no build step, no dependencies.