[opensourcedex]

pm-brain is a free, open source note taking & knowledge management project written in Python and released under MIT. It has 868 GitHub stars, 171 forks and 3 open issues, and was last pushed 4 months ago. On this registry it ranks #33 of 37 tracked projects in Note Taking & Knowledge Management, with 5 head-to-head comparisons available.

What is pm-brain?

PM Brain is an MIT-licensed Claude Code skill that gives a product manager a second brain made of plain markdown files in a local folder, which Claude reads before answering, writes to after, and sweeps every Friday.

What it is

PM Brain is a skill for Claude Code that turns a directory of ordinary markdown files into durable working memory for one product manager. The files sit in a folder on the user's laptop. There is no vector database, no cloud service, and no agent memory trickery; Claude reads the folder before it answers and writes back to it afterward. The repository also ships the companion project pm-skills, and the skill itself installs globally into ~/.claude/skills/pm-brain/ so it is available across every Claude Code session in any working directory.

The concrete problem it solves is context loss. A PM's knowledge is scattered across Notion, Linear, Slack, dashboards, and memory. A feature ships, and six weeks later nobody remembers why the alternative option was killed. PM Brain captures that reasoning in a folder the PM owns and can read, diff, and commit like any other text. It lives in the Claude Code ecosystem, and the specific thing it replaces is ad-hoc agent memory and scattered note stores as the place reasoning actually lives.

Key capabilities

  • Bootstraps a brain in any folder with the /pm-brain command, choosing between greenfield mode for an empty directory and migration mode for a folder that already holds PM artifacts.
  • Reads existing Notion exports, Jira CSV files, and meeting notes during migration, then absorbs them into the scaffold.
  • Runs a five-batch interview that captures company, role, and current priorities before the scaffold drops in.
  • Stores everything as plain markdown with no vector DB, no cloud, and no agent memory tricks.
  • Ingests transcripts, documents, screenshots, individual lines of chat, and app-connector pulls through the single ingest step of its one loop.
  • Commits the brain locally and never pushes, so product context never leaves the machine by default.
  • Ships an eval suite recorded in tests/RESULTS.md that passes 404 of 406 checks, roughly 99.5 percent.

Who uses it and how

  • A PM managing a single product whose context is spread across Notion, Linear, Slack, and dashboards, and who wants one durable folder instead.
  • A PM starting fresh on a new product, who points an empty directory at /pm-brain and gets a scaffolded brain plus an interview on company, role, and priorities.
  • A PM joining an existing team, who runs migration mode against live strategy, in-flight hypotheses, recent decisions, and the current stakeholder list rather than backfilling history.
  • New users following docs/walkthrough.md, a short story of one PM, Lena, using PM Brain through her first five days on a real team.
  • PMs who need durable reasoning about a killed option to survive past the six-week mark, which is the failure mode the README names directly.

Getting started

Installation is two stages: extract the skill folder into ~/.claude/skills/pm-brain/ with the provided curl and tar command on macOS, Linux, WSL, or Git Bash, or the PowerShell equivalent on Windows, then run claude in the folder that should hold the brain and enter /pm-brain. A universal fallback for any OS with git is git clone https://github.com/phuryn/pm-brain.git && cp -R pm-brain/.claude/skills/pm-brain ~/.claude/skills/.

How it compares

The registry names no direct equivalent to this project. Its closest named relative is the companion repository pm-skills, which is a separate skill rather than a competing tool, and the Notion, Linear, and Slack mentions describe scattered context sources instead of rivals. On the evidence provided, PM Brain stands alone in this registry.

When to use it — and when not to

Choose PM Brain when one PM wants a local, text-owned memory layer inside Claude Code and is willing to run a skill install plus a folder bootstrap. Avoid it if the team needs a shared, multi-user knowledge base, because the brain commits locally and never pushes, and nothing in the facts describes hosted sync, server-side storage, or backup. It is also honest to call this a research preview: the architecture has months of dogfooding on a sister content brain, but the product as installed by real PMs is only days old, so the passing eval suite is a floor rather than a guarantee.

project readme (upstream, from github) — read inline

PM Brain

Claude Code skill License: MIT Tests: 404/406 checks (≈99.5%) Companion: pm-skills

A second brain for product managers. Plain markdown files in a folder on your laptop. Claude reads them before answering, writes to them after, sweeps them every Friday. No vector DB. No cloud. No agent memory tricks.

You manage one product. Your context is scattered across Notion, Linear, Slack, your dashboards, and your head. You ship a feature. Six weeks later, nobody remembers why you killed the other option. PM Brain fixes that.

See it in action: A week with PM Brain: Lena's first five days is a short story of one PM using it on a real team. New here? Start there.

Research preview. The architecture has months of dogfooding behind it on a sister content brain; the product as installed by real PMs in real organizations is days old. The eval suite (404 of 406 checks pass) is the floor. Real-world install feedback is how the next version gets better. Open issues or join the conversation per the launch post.

Install

Two stages: install the skill once, then bootstrap a brain in any folder you want.

Stage 1: install the skill (one time)

The skill is global. It lands in ~/.claude/skills/pm-brain/ and is available across every Claude Code session, in any working directory.

macOS / Linux / WSL / Git Bash:

mkdir -p ~/.claude/skills && \
  curl -L https://github.com/phuryn/pm-brain/archive/refs/heads/main.tar.gz | \
  tar xz --strip-components=3 -C ~/.claude/skills pm-brain-main/.claude/skills/pm-brain/

Windows PowerShell:

$dest = "$env:USERPROFILE\.claude\skills"
New-Item -ItemType Directory -Force -Path $dest | Out-Null
irm "https://github.com/phuryn/pm-brain/archive/refs/heads/main.zip" -OutFile "$env:TEMP\pmb.zip"
Expand-Archive "$env:TEMP\pmb.zip" "$env:TEMP\pmb" -Force
Copy-Item "$env:TEMP\pmb\pm-brain-main\.claude\skills\pm-brain" $dest -Recurse -Force
Remove-Item "$env:TEMP\pmb.zip","$env:TEMP\pmb" -Recurse -Force

Either path pulls only the skill folder (.claude/skills/pm-brain/) into your Claude Code skills directory. The rest of this repo (example-brain/, tests/, docs/) stays on GitHub for you to browse, not on your laptop.

Stage 2: bootstrap a brain (per-product)

In any folder where you want the brain to live:

cd ~/projects/my-product-brain
claude
# then in the Claude Code prompt:
/pm-brain

The skill detects what's already in the directory. An empty folder gets a fresh start (greenfield). A folder with existing PM artifacts (Notion exports, a Jira CSV, meeting notes) gets read and absorbed (migration). Either way, a short 5-batch interview captures company, role, and current priorities. The scaffold drops in, the brain commits locally. Never pushes.

Migration is for your current state. Don't backfill old artifacts retroactively. Migration mode reads your active strategy, in-flight hypotheses, recent decisions, current stakeholder list. That's the goal. Don't try to manually /ingest 200 old interview transcripts and six months of Slack threads. If a stale artifact matters, it'll come up through current work and you'll ingest it then. Forcing them in now wastes a weekend and clogs the durable layer.

Stuck? Universal fallback (any OS with git): git clone https://github.com/phuryn/pm-brain.git && cp -R pm-brain/.claude/skills/pm-brain ~/.claude/skills/. On Windows replace the cp -R with Copy-Item pm-brain\.claude\skills\pm-brain $env:USERPROFILE\.claude\skills\ -Recurse.

What it does (one loop)

The brain has one loop. Every task runs through it.

  1. Ingest. Feed it an artifact (transcript, doc, screenshot, line in chat, app-connector pull from Notion / Jira / Slack).
  2. Source + synthesize. The original copies to source/ (immutable). The synthesis lands in ingestion/ with observations tagged by speaker and date.
  3. Propagate. The durable layer (knowledge/, hypotheses/, decisions/, stakeholders/) gets updated wherever the new signal applies. One artifact often touches four to six files.
  4. Tag. Every load-bearing claim wears a provenance marker: a documented interview, a verbal stakeholder comment, your hunch, or general industry knowledge. The tags carry an implicit hierarchy: documented outweighs verbal, verbal outweighs intuition. The weighting is in plain text, so you can see when the brain is leaning on it and override it when your judgment says otherwise.
  5. Sweep. Friday's /review reads the whole folder, flags what's drifting, drafts what needs your call.

Full list of provenance tags in the glossary. Worked end-to-end example: how it works.

The six commands

Command What it does
/ingest Feed an artifact into the brain: a file, a paste, a quick note in chat. The skill figures out the shape (interview, meeting, market signal, ad-hoc) and routes it.
/prep One-page brief before a meeting: their open asks, last unresolved concern, suggested questions.
/review Weekly sweep. Six checks across the brain. Fixes small things directly, drafts the bigger ones for your call.
/ideate Synthesis, not brainstorm. Loads strategy, insights, and hypotheses. Surfaces 3–7 directions, each tagged with the evidence behind it.
/risk Five-area risk scan. Drafts hypothesis stubs for any area with no coverage.
/plan Six-block draft plan: what we know, assumption vs evidence, who to interview, hypotheses to open, experiments to run, decision points.

What's in the repo

.claude/skills/pm-brain/    # The canonical skill. Install this.
example-brain/              # Pre-scaffolded instance (browseable demo)
tests/                      # Eval suite. Synthetic scenarios + harness.
docs/                       # Architecture, how it works, testing, prior art

The brain itself (once you install and run /pm-brain) lives in your working directory:

  • knowledge/: your stable picture of strategy, product, users, market, and org
  • hypotheses/: things you're tracking the evidence for (e.g., "invite-link friction blocks team activation under 50 seats")
  • decisions/: calls you've made, with the evidence trail and what would reopen them
  • stakeholders/: one file per person, with their asks and concerns
  • ingestion/: synthesis of every interview, meeting, doc, or message the brain has read
  • source/: the untouched originals, so the audit trail stays intact

What it isn't

  • Not a notes app. It's an opinionated structure with maintenance built in.
  • Not a chatbot with memory. The memory lives in your repo, not in Claude.
  • Not a vector database. Every file is plain markdown, grep-able by you.
  • Not an agent memory system. Nothing is embedded, nothing is retrieved by similarity. The brain stores only what you and the agent deliberately wrote down.
  • Not autonomous product management. Judgment stays with you. The brain makes the boring cross-referencing easier.

Tests

17 synthetic PM scenarios. 404 of 406 individual checks pass across the snapshots (≈99.5%). The split: every structural check passes (329 / 329, 100%). Files exist, links resolve, evidence rows tagged, decision schemas valid. And 75 of 77 LLM-judge content checks pass (≈97%), with two judges missing on the two longest scenarios. Full breakdown in the scoreboard.

Each scenario is a multi-turn PM situation (a churn investigation, a stakeholder cadence flag, a contradiction arriving 60 days after a decision) with cached input artifacts and ground-truth assertions. The harness spins up a fresh brain in a temp dir, replays the inputs through claude -p, runs structural assertions after every turn, and runs LLM-judge rubrics on substance at scenario end.

python tests/harness/run_scenario.py tests/scenarios/01-b2b-churn
  • tests/RESULTS.md: scoreboard, per-scenario JSON snapshots, the two known residual judge failures (called out honestly, not hidden)
  • tests/README.md: 90-second operator quickstart
  • tests/TESTING.md: scenario format, ground-truth schema, harness internals, cost model, coverage map
  • docs/testing.md: design rationale (why scenarios over per-turn unit tests, why LLM-as-judge is reserved)
  • **

readme truncated — read the full docs on github

Frequently asked questions

Is pm-brain free to use?

pm-brain is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does pm-brain do?

PM Brain OS: The Second Brain for Product Managers, Made of Markdown

What is pm-brain written in?

pm-brain is primarily written in Python. Its source is publicly available at https://github.com/phuryn/pm-brain, and it has 868 GitHub stars.