PM Agent

An autonomous product-manager agent that lives entirely inside Claude Code. Fork it, run one onboarding conversation, and you have a senior-level, opinionated PM embedded in your organization — one that runs spec intakes, challenges scope, generates versioned artifacts, tracks a project portfolio in persistent memory, and (optionally) mines your work artifacts into a cited knowledge base.

No backend. No database. No framework. The entire agent is markdown instructions + a git repo as its brain.

---

What it does

• Spec intake as a conversation. /pm runs a PM-driven intake: sharp questions one or two at a time, scope challenged by default, a mandatory success metric, a mandatory adoption plan, and a recommended build target. It ends by generating an executive 1-pager and an engineering spec (and a branded deck, if you configure a template).
• Strategy mode. /pm-strat produces strategy/program docs for initiatives, committees, and exec communication.
• Persistent, cheap memory. A three-tier system (registry → org-wide facts → per-project files) keeps context flat as projects accumulate. Sessions end by writing decisions — not transcripts — back to memory.
• Task tracking. /task maintains per-project work items, kept strictly separate from open questions (decisions not yet made).
• Knowledge system (optional). /mine ingests meeting transcripts, decks, and docs through a Python pipeline into an event-sourced knowledge base — entities + claims, every claim carrying a verbatim quote and provenance. /ask answers questions about your job context with citations.
• Engineering judgment that compounds. The agent researches implementation approaches before writing specs, checks its eng-knowledge/ corpus first, and writes what it learns back — the corpus ships seeded with 10 real patterns.

Quickstart (5 minutes)

# 1. Fork or clone this repo, then open it in Claude Code
cd pm-agent
claude

# 2. Onboard — one conversation sets up your org context
/kickoff

# 3. Spec your first agent/automation
/pm

/kickoff interviews you (who you are, what your org does, your platform standards, your constraints), writes config.yml + memory/global.md, and optionally enables the deck and knowledge-miner modules. Everything after that is a conversation.

Commands

Command	Purpose
/kickoff	Onboard a fresh fork (run once)
/pm	Start or resume an agent/automation spec session (Mode 1)
/pm-strat	Strategy / program / enablement doc (Mode 2)
/pm-resume [slug]	Resume a specific project
/pm-status [slug]	Project dashboard
/pm-update [slug]	Conversational project update
/pm-list	List all projects
/pm-regen [slug]	Regenerate artifacts as new versions
/pm-export [slug]	Export specs to .docx (pandoc)
/pm-sync [slug]	Sync tracked-change feedback from .docx back to markdown
/pm-archive [slug]	Archive a project
/pm-brainstorm	Freeform ideation — nothing written
/task	Per-project task tracker
/dash	Control center — portfolio, tasks, health
/save	End-of-session memory write + safe git sync
/pull	Read-only session-start sync
/mine /ask /mine-eval /queue	Knowledge system (optional module)

Memory architecture

Tier	File	Always loaded	Purpose
1	memory/index.md	Yes	Lightweight registry of all projects
2	memory/global.md	Yes	Org-wide facts, platform standards, constraints
3	memory/projects/[slug].md	On demand	Full context for the active project only

The agent reads tiers 1–2 at session start, loads tier 3 only when a project is identified, and writes decisions back at session end. Because memory is files in git, every decision has history, and every surface you run Claude on shares one brain.

Artifacts

Every completed spec session generates versioned artifacts under projects/[type]s/[slug]/:

Artifact	Format	Notes
Executive 1-pager	.md	Leadership-facing summary
Engineering spec	.md	Build-ready, scope-tagged technical spec
Deck	.pptx	Only if you configure a branded template (see templates/)

Filenames follow [slug]-[type]-[artifact]-[YYYY-MM-DD]-v[N].[ext]; artifacts are never overwritten. /pm-export produces .docx copies for tracked-change review, and /pm-sync folds reviewer feedback back into a new markdown version.

Run it in Claude Code cloud (persistent, anywhere-access)

The repo is the agent — so anywhere Claude Code can reach the repo, your PM agent is there with full memory.

1. Push your fork to GitHub (private is fine).
2. Go to claude.ai/code and connect the repo.
3. Start sessions from any device with the Claude app — desktop, web, or mobile. Cloud sessions run in the background and persist after you close your laptop.

Multi-surface hygiene: start sessions with /pull (read-only sync) and end them with /save (memory write + commit + rebase + push, never force). Cloud sessions typically run on their own branches; merge back via PR. The one file that sees frequent concurrent edits is memory/index.md, and rebases handle it cleanly because different sessions touch different entries.

Optional modules

Branded decks — drop your .pptx template in templates/, let /kickoff build a layout manifest, and sessions generate branded decks. See templates/README.md.

Knowledge miner — requires Python 3.10+ and an Anthropic API key:

pip install -r miner/requirements.txt
export ANTHROPIC_API_KEY=sk-ant-...
export PM_EXTRACTION_MODEL=<latest Claude Opus model id>

Then set modules.knowledge_miner: true in config.yml (or let /kickoff do it). Drop files in knowledge/raw-inputs/_inbox/ and run /mine. Invariants: canonical views are always recomputed from the full raw ledger; every claim carries a verbatim quote + provenance; citations are validated, not trusted. See knowledge/README.md.

Repo layout

CLAUDE.md            the agent — identity, protocols, behavior rules
config.yml           your identity + enabled modules (written by /kickoff)
.claude/commands/    slash commands
skills/              artifact-generation + discipline skills (scope, prune, eng-research)
memory/              the three-tier brain
projects/            generated specs, decks, exports (by project type)
eng-knowledge/       seeded engineering-pattern corpus (compounds over time)
knowledge/ + miner/  optional knowledge system (event-sourced, cited)
templates/           your branded .pptx template (optional)

Requirements

• Claude Code
• git; pandoc for .docx export; Python 3.10+ only for the optional modules (python-pptx for decks, miner/requirements.txt for the knowledge system)

License

MIT