Your agent wrote it. Now it walks you through it.

Code Review Party turns a Claude Code session into a guided code review. The agent explains its own change one step at a time, in the order that makes sense, and every step points at the exact lines it's talking about.

Download for Mac Free for personal use. Version 0.1.0, macOS 13 or later.
A narrative in Code Review Party: the agent's summary of a change and a diagram of how a new todo flows from the form to the API, then step one, pinned to the highlighted lines of the form component.

There's more code to review than anyone can read.

One prompt to a coding agent can touch thirty files. Five prompts and the branch is bigger than anything your team used to merge in a week. The code arrives faster than you can review it, and it keeps arriving.

A diff doesn't help much. It lists files alphabetically, buries the one change that matters between lockfile churn and renamed imports, and never says why. So you skim, approve, and hope.

34 files changed, +2,118 −406
  1. migrations/0042_org_billing.sql++++++
  2. package-lock.json++++++++−−
  3. src/api/billing/invoices.ts+++++++
  4. src/api/billing/webhooks.ts++++++−
  5. src/api/orgs/members.ts++−−−
  6. src/auth/permissions.ts+++−
  7. src/components/BillingPage.tsx+++++++
  8. src/components/InvoiceTable.tsx+++++
  9. src/components/PlanPicker.tsx++++−−
  10. src/components/SeatCounter.tsx+++
  11. src/db/schema.ts++++−
  12. src/hooks/useSubscription.ts++++
  13. src/lib/money.ts++−−
  14. src/lib/stripe.ts+++++−
  15. src/routes.tsx+−
  16. src/services/billing.ts++++++−−
  17. src/services/orgs.ts++−−−−
  18. tests/billing/invoices.test.ts++++++
  19. tests/billing/webhooks.test.ts+++++
  20. tests/orgs/members.test.ts+−−

So the author explains it, the way a good reviewer would want.

When Claude Code finishes a piece of work, it writes a narrative: a walkthrough of its own change, aimed at you.

It explains the change in order.

First what the change is for, then the code in the order that makes sense: form, then service, then route. Not alphabetical. Each step is one idea, with a few sentences on why it's built that way.

Org billing, from the plan picker to the Stripe webhook

Lets an organization pay for seats. We follow one upgrade from the plan picker, through the billing service and Stripe, to the webhook that records it.

  1. The plan picker sends a seat count, not a price
  2. The service creates the checkout and owns the mapping
  3. The webhook is the only writer of the subscription
  4. Seats are checked where members are added
The opening of a narrative for the 34-file change above.

Every step points at its lines.

The code a step talks about is highlighted beside it, across as many files as it needs. The narrative ends with what deserves a careful look and what isn't done yet.

A narrative step pinned to highlighted lines in two files, the route handler and the client service.

Ask the author.

Select a few lines and ask a question. It goes to the Claude Code session that wrote them, and the answer appears right there.

A question about two selected lines of a route handler, with the agent's answer underneath.

The raw material is still there when you want it.

The Changes view: changed files on the left, a split diff on the right.

A live diff

Every file the agent touched, refreshed as it edits. The whole branch against its base, or only what's uncommitted. Split or unified, in your diff theme.

The Timeline: turns listed on the left, and for one turn the prompt, the agent's messages and a diff per changed file.

A timeline of every prompt

What each prompt actually changed, one diff per file, whether the agent used its edit tool, sed, a formatter or a rename.

Two minutes to set up.

  1. Install the app

    Drag it to Applications. It lives in the menu bar and keeps itself up to date.

  2. Add the plugin

    One click in Settings installs the Claude Code plugin that teaches the agent to narrate.

  3. Work as usual

    Start Claude Code in a repository. The app opens on it, and the first narrative arrives when the work does.

It reads your repository. It never writes to it.

Read-only by construction
The app's git access goes through one module with no writing calls in it, and the test suite fails if one appears. No files, no .git changes, nothing added to your project.
Nothing leaves your Mac
The app and Claude Code talk over 127.0.0.1. Narratives, snapshots and questions stay in the app's own data folder. No account, no telemetry.
Your agent writes the narratives
They come from the Claude Code session you're already running, written in a background fork so your work isn't held up. Nothing goes through a server of ours.

Free for personal use. $30 for work.

Side projects and open source cost nothing. For work, one person pays $30 once and a team of up to 20 pays $500 once. Every update is included, and nothing is locked either way.

See pricing

Questions people ask

Isn't this just asking the agent to summarize its diff?

A summary tells you what changed. A narrative is ordered for understanding, pins every claim to the lines behind it, keeps those pins accurate as the code moves on, and lets you question the author about any of them. It's the walkthrough a careful colleague would give you at their desk.

Does it slow the agent down?

No. Narratives are written in a forked session after a piece of work is done, so your main session carries on. Snapshots of the working tree take milliseconds.

What does it cost in tokens?

A narrative is a few thousand tokens of the agent reading its own diff and writing about it, on your existing Anthropic plan. Answering a question costs about what asking it in the terminal would.

Does it work with other agents?

Claude Code only, for now. The hooks and tools it relies on are Claude Code's.

Windows or Linux?

macOS only for now. The core is cross-platform Rust, so other platforms are a matter of time and testing.