Now in public betav0.8

Understand any codebase
in seconds.

CommitMind captures what your team decided and makes it instantly available to every AI session.

Try it on your repoSee a 5s demo
$ curl -fsSL commitmind.dev/install | shNo credit card · Local by default · MIT CLI
commitmind · ~/work/payments-service⎇ main · a1b2c3d
~/payments-service$ commitmind prime
Priming context · 124 decisions · 8 contributors
What this project does
Handles outbound payouts + reconciliation for Stripe + Adyen. Owns the idempotency_keys table and the nightly reconciler.
Recent changes (7d)
  • a1b2c3d Adopt OAuth 2.1 PKCE for partner API accepted
  • 9f2e801 Pin React to 18.3 proposed
  • 7a0b133 Move search to Postgres FTS accepted
Key decisions you should know
  • Payouts are fire-and-forget; retries handled by the outbox worker, not the caller.
  • We chose Postgres FTS over Elastic to drop one infra dependency.
  • Never write directly to ledger_entries — use the post_entry RPC.
Risks & stale assumptions
  • stale Webhook retry doc references /v1/legacy-webhook — superseded 3w ago.
  • open Refresh token rotation decision is proposed, not accepted.
Context primed in 4.2s · attached to session ses_7yk2
The 5-second tour

One command. Your AI knows your project.

No embeddings config. No vector store to tune. Drop the CLI in any repo and run prime.

commitmind · ~/work/payments-service⎇ main · a1b2c3d
~/payments-service$ commitmind prime
Priming context · 124 decisions · 8 contributors
What this project does
Handles outbound payouts + reconciliation for Stripe + Adyen. Owns the idempotency_keys table and the nightly reconciler.
Recent changes (7d)
  • a1b2c3d Adopt OAuth 2.1 PKCE for partner API accepted
  • 9f2e801 Pin React to 18.3 proposed
  • 7a0b133 Move search to Postgres FTS accepted
Key decisions you should know
  • Payouts are fire-and-forget; retries handled by the outbox worker, not the caller.
  • We chose Postgres FTS over Elastic to drop one infra dependency.
  • Never write directly to ledger_entries — use the post_entry RPC.
Risks & stale assumptions
  • stale Webhook retry doc references /v1/legacy-webhook — superseded 3w ago.
  • open Refresh token rotation decision is proposed, not accepted.
Context primed in 4.2s · attached to session ses_7yk2
01
What this project does
Surfaced from README + commit graph + your team's captured decisions — not guessed.
02
Recent changes, with status
Commits pair with the decision behind them: accepted, proposed, superseded.
03
Risks & stale assumptions
Catches when a doc or comment still references code your team already deprecated.
→
In under 5 seconds, your AI knows your project.
Attach to Claude, Cursor, Copilot, or any MCP-compatible client.
Every day, on every repo

You keep asking
the same four questions.

"Why is this code like this?"
"What changed last week?"
"Why did we do it this way?"
"Why is the AI suggesting the wrong thing?"
CommitMind fixes this.
How it works

Three steps. No config file.

01
Capture
Every commit is annotated with the observation, decision, and reasoning behind it. Via CLI, PR hook, or editor.
$ commitmind note "switched to PKCE — SSO parity"
02
Anchor
Decisions are anchored to the exact SHA they live on. When code moves, the decision moves with it.
decision d_8f20 → a1b2c3d · accepted
03
Retrieve
Your AI session calls `prime` and gets the right context — not a 30k-token README dump.
$ commitmind prime --session=$CLAUDE_SESSION
Team magic

Your teammate's context
becomes your context.

The decision you made Tuesday is the context your teammate's AI uses on Thursday. No meeting. No Loom. No ADR doc no one reads.

Decide once
The first dev to resolve an ambiguity teaches everyone.
Zero re-litigation
No one relearns why you picked Postgres FTS over Elastic.
Onboarding in days, not months
New hire's first `prime` is the last team-knowledge gap.
EM
Erin
Tuesday, 2:14pm
$ commitmind note
"Using OAuth PKCE for SSO parity"
decision · committed
committed to graph
JN
Jun
Thursday, 9:02am
AI "Should we use session cookies?"
Your team already decided: OAuth PKCE (Tue, @erin).
context · surfaced automatically
Safety, not just memory

Stop your AI
from being wrong.

CommitMind knows which decisions are stale, superseded, or disputed — and refuses to serve them as context.

Stale context detection
Flags decisions whose underlying code has materially changed.
Decision awareness
AI never sees rejected or superseded reasoning as current truth.
Fewer bad suggestions
Internal benchmarks: 42% fewer hallucinated API calls on primed sessions.
Economics

Stop paying tokens to remember things.

Smaller prompts. Fewer retries. Faster onboarding. The math is simple.

−74%
context tokens per session
vs. dumping the full repo into every prompt
−3.1×
retries to a correct suggestion
measured across 400 primed vs. unprimed Claude sessions
4 days
from new hire to first merged PR
median across 12 customer teams in the beta
Before CommitMind
Paste README into every prompt
28k tokens of stale comments
Three retries to get the right API
≈ 28,400 tokens / session
With CommitMind
One prime call, scoped to the task
Only accepted, non-stale decisions
One prompt, correct answer
≈ 7,380 tokens / session
See it in action

Same prompt. Better answer.

Pick your client. Watch what changes when CommitMind is attached.

prompt"Refactor the refresh token flow."
Without CommitMind
Generates code that still uses the old cookie session and calls /v1/legacy-webhook.
With CommitMind primed
Uses OAuth 2.1 PKCE (your team's accepted decision, a1b2c3d) and the v2 signed payload.
Pricing

Priced per dev. Free forever for one repo.

No seat minimums. No sales call required. Cancel from the CLI.

Free
For solo devs
$0forever
  • 1 repo
  • Local CLI
  • Up to 100 decisions
  • Community support
Most popular
Pro
Most popular
$20/ dev / mo
  • Unlimited repos
  • Unlimited decisions
  • Claude / Cursor / Copilot
  • Stale-context detection
  • Priority support
Team
For teams shipping together
$30/ dev / mo
  • Everything in Pro
  • Shared team graph
  • SSO + SCIM
  • Audit log
  • Dedicated Slack channel
Built for devs who read the docs

Technical credibility, not security theater.

Git-anchored
Every decision lives on a SHA. When code moves, decisions move with it. No orphan knowledge.
Project-scoped
One repo's decisions never leak into another's AI context. By construction, not policy.
Local by default
Code never leaves your machine unless you explicitly ship it. Self-hosted Team plan available.
Open architecture
MCP-compatible. Works with any client. The graph format is documented and portable.
Ready?

Never start a session
without context again.

Paste this into your terminal —
$ curl -fsSL commitmind.dev/install | sh
Works with Claude Code · Cursor · Copilot · Zed · any MCP client