Local git review, worked with Claude · Apple Silicon

Read every change before it counts.

Changeset turns everything you haven't committed into a review on your own machine. Leave a note on any line and Claude works it as a thread: it answers, proposes, and edits your files only after you approve. A file is reviewed when you stage it.

Get Changeset How it works

needs the Claude Code CLI and your own Claude subscription for the Claude features · git on your PATH · see dependencies

Why this exists

Code generation is the easy part. Quality is now the challenge.

AI tools produce more change than anyone planned to read. The hard part is no longer writing it; it is reasoning about the volume of it. Changeset is the gate where every change is actually read, where Claude does the rework you ask for, and where you commit only what passes your standards.

How it works

How a change gets reviewed.

1
Read the diff
Staged, unstaged and untracked, split the way git splits them, with the changed words tinted inside each line.
2
Leave a note
On a file or on a single line. Every note is a thread: ask a question, flag a problem, or ask for a change in your own words.
3
Activate it
A Claude agent picks the thread up, reads the code, and answers or proposes. It changes files only after you approve.
4
Review it, then stage it
Claude's edits land back in the diff for you to read. Marking a file reviewed runs git add: the review state is the git index itself.

Highlights

Worth a closer look.

A complement to your code editor

Changeset doesn’t replace the editor you write code in; it sits beside it. You won’t edit your files in Changeset: write the code in your editor, save, and the diff updates in place, with a note naming the file that just changed. Then read it, talk it over with Claude and stage it here.

Tag notes your way

Tag a note feature, bug, backlog, issue, phase 1 or anything else you like. There is no fixed list and no limit, and picking a tag filters the list down to it.

Reviewing a file stages it

Mark a file reviewed and Changeset runs git add on exactly that file, nothing else. Your progress is the git index itself.

Capture ideas as they come

Ideas arrive faster than code. Drop each one into a note the moment it comes, on a line, on a file or on its own, and hand it to Claude when you’re ready.

Continue in any terminal

Changeset serves its threads over MCP, so the work isn’t tied to its window. Connect your own Claude Code session in Settings: paste the two lines it gives you into any terminal on your computer, approve the sign-in in Changeset, and carry on with a thread from there. After that, a thread’s own Work in Claude Code hands it to that session.

Hand a thread to your own Claude Code

Every thread’s header has Work in Claude Code beside Activate. Open in terminal starts Claude Code in the repository with the thread’s prompt already typed; Copy prompt puts that prompt on your clipboard for a session you already have open. Press Enter and Claude works that thread, replying where you will read it.

Settle it before it’s built

Ask for a plan, the test cases and a mockup before any work starts. Claude writes the plan and the tests into the thread for your approval, with the mockup beside them, and every point waiting on you gathers in one Decisions window. Nothing is built until you approve it.

A local MCP server for your notes

Changeset is an MCP server for your notes and backlog, running on your own computer. Any Claude Code session you connect can file notes into your backlog, see what’s still open and pick a thread up, in the repositories you trust.

Your notes live where you choose

Every thread, and every design or file Claude made for it, is kept as plain files in a folder you choose, never on a server of ours. That folder starts in Documents, so if your cloud storage already syncs Documents, as iCloud Drive can, your notes are kept on storage you already have, with no extra monthly subscription. Or keep them in a folder that stays on this computer.

Documents/
└─ Changeset/
   ├─ notes/
   │  └─ coffee-shop/
   │     ├─ 2026-10-17T09-12-03.417Z-k3x9p2ab/
   │     │  ├─ notes.json
   │     │  └─ artifacts/
   │     └─ archive/
   └─ config/
      └─ quick-replies.json

Where the folder starts. Move it whenever you like from Changeset's control panel: every file is copied and checked before the old copy is removed.

Your whole project in one place

In a terminal, a good idea scrolls away under the next wall of output. In Changeset every goal, feature, bug and idea is a thread in one list for the repository: narrow it to a phase, resolve what is settled, and see exactly what is left. However sprawling the project gets, you stay on top of it, and not one idea is lost.

Done means done: resolve it or archive it

When a thread is settled, resolve it from its ⋯ menu. It leaves the list, so what’s left is what still needs you, and the resolved filter brings it back the moment you want it. When you’re finished with a thread for good, archive it: it moves out of the list into the repository’s archive, still on disk, where Unarchive brings it back. Either way, closing a thread stops its agent.

Never lose a decision again

In a terminal, the questions Claude asks you are buried in its replies, and the ones you meant to answer later slip away. Changeset collects each one as a decision of its own, with what Claude proposes, in the thread’s Decisions window. Claude proposes; you decide, one point at a time.

Every proposal waits for you to approve or reject it before any work starts.
Answer each point on its own: approve it, reject it, send it back with a note, or mark it not needed. Tabs show what is still waiting for you and what is settled.
Save asks Claude to write the approved ones into your project, word for word, and each decision then shows the file and line it went to.
A thread keeps a standing plan, a spec and a summary, rendered in your theme and revised as the work moves.
Designs, images and files Claude produces are kept with the thread, ready to open.

What's in it

Everything a careful review needs, and an agent to make the changes you ask for.

Reading the diff

Built for the read, not the merge.

Changed words are tinted inside the line, so a rename never reads as a rewrite.
Syntax colour is computed on your own machine; nothing downloads a grammar.
A half-staged file appears twice: the part you approved and the part still waiting.
Every file in one continuous scroll, or one at a time.
Edits on disk show up in the open diff within seconds, and a note in the corner names the file that just changed.
Mark a file reviewed and its header turns green while the next file glides in.
Markdown and code open in a preview over the diff, with contents and a note gutter.

Threads Claude works with you

Each note is a conversation with an agent of its own.

Activate a thread and a Claude agent picks it up. Activate several and they work side by side.
An agent claims the files it is about to edit, so two agents never write the same file; a second one waits its turn.
A live status card shows what each agent is doing, and Stop ends it at once.
Each thread keeps its own conversation and resumes it, told exactly which files changed while it was away.
Pick the model and effort per thread, from what your installed Claude Code offers.
Nothing starts on its own: an agent only ever runs because you activated its thread.

Nothing slips through

The threads double as your backlog.

Tags of your own, plus unread, unanswered and active at a glance.
Resolve what is done, archive what you are finished with, and filter down to what is left.
Quick replies you set up yourself, one tap away.
A permalink reopens the exact file, side and line range.
Five themes with lightness and contrast controls, applied before the first paint.

The review model

Reviewed isn't a checkbox. It's the index.

Changeset keeps no table of what you have looked at. A file is reviewed when it is fully staged, so the state lives in the one place you and your tools already trust, and it survives quitting the app, switching machines, or never opening it again.

git add

Reviewed means staged

Marking a file reviewed stages exactly that path, and touches nothing else.

git reset

Un-reviewing unstages

Changed your mind? Un-review moves the entry back, after asking, because it is a real edit to your staging area.

git diff --cached

Progress is derived

What you have reviewed is read from git every time. There is no database to drift or migrate.

Boundaries

What it will never do to your code.

Your files: Never unasked. Reviewing only ever writes the git index. Claude edits the working tree when YOU ask it to, never on its own, and every edit lands back in the diff before it counts as reviewed.
Stale bytes: Never staged. If a file changed while you were reading it, staging stops and tells you, so nobody stages bytes nobody read.
Outside the repo: Never read. Every path is resolved and checked against the repositories you added, symbolic links and .. included.
The network: Never left. It listens only on this computer, with no telemetry and no account inside the app. The one exception is Claude: when you ask Claude for something, what it reads goes to Anthropic.

Dependencies

What it needs from you.

Changeset brings its own runtime and local server, so there is no JavaScript runtime, package manager or toolchain to install. It relies on a few things it does not bring.

1
Claude Code CLI
claudeFor the Claude features
Anthropic’s command-line tool, installed and signed in. Every thread you activate runs on your own copy.
2
A Claude subscription
For the Claude features
Your own, billed separately by Anthropic. Changeset neither includes nor resells it.
3
git
Required
Installed and on your PATH. Changeset runs the copy already on your computer.

Without Claude Code or a subscription, reading the diff, leaving notes and reviewing all still work: Claude just can't answer notes or change your files.

Get it

Version 0.13.0

$7.00, one-time purchase

$2.00 to upgrade, if you own an earlier version

Changeset goes on sale here soon.

No subscription. You own that version, forever.

Available for Apple Silicon.

Questions about licensing, teams or another platform? Contact us.

A Claude subscription is required for the Claude features

They run on your own Claude subscription, billed separately by Anthropic. Changeset neither includes nor resells it, and without one, reading the diff, leaving notes and reviewing all still work.

One repository. Everything you haven't committed.

Get Changeset How it works

Apple Silicon · runs on your own machine · borrows only the Claude Code CLI and git from your system