Desktop app

Windows

Apple Silicon

Local git review with coding agents

Better code review.Better project management.One place.

Once you’ve organized your code project this way, there’s no going back.

Intentional software engineering,human-in-the-loop.

You don’t want your codebase turning into a pile of slop that no one can understand and maintain. You want to get back to software that endures, not software that's disposable.

Start with notes,end with shipped.

These notes become conversation threads between you and your coding agent. Notes can be marked as resolved for backlog management.

Changeset is a cross-platform desktop app. It turns everything you haven’t committed into a review, right on your machine. Leave a note on any line and your own coding agent works it as a thread, over MCP: it answers, proposes, and edits your files only after you approve. A file is reviewed when you stage it.

needs a coding agent and your own subscription to it for the agent features · git on your PATH · see dependencies

From first open to your first answer

  • Your notes live where you choose: every thread, and every design or file your agent 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.
  • Move the folder whenever you like from Settings: every file is copied and checked before the old copy is removed.
  • Add your repository, leave a note on a line and switch the thread to Active. The second welcome page lays out the four setup steps, and the Work in panel, in the thread’s header, copies the line that connects your agent and the prompt that keeps it checking for your replies.
  • Paste the thread’s prompt into your agent in a terminal, and it answers in the thread with a proposal. Nothing changes until you approve.

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 your agent does the rework you ask for, and where you commit only what passes your standards.

How it works

How a change gets reviewed.

  1. 1

    Read the diff

    Staged, unstaged and untracked, split the way git splits them, with the changed words tinted inside each line.

  2. 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. 3

    Hand it to your agent

    Work in, in the thread’s header, hands the thread to a session of your own coding agent, which reads the code through Changeset’s tools and answers or proposes. It changes files only after you approve.

  4. 4

    Review it, then stage it

    Your agent'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.

Review the code

Built for the read, not the merge

Everything you haven’t committed, in one place: unstaged, staged and untracked, split the way git splits them.

  • 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.
  • Markdown and code open in a preview over the diff, with contents and a note gutter.
  • A permalink reopens the exact file, side and line range.

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 your agent and stage it here.

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.

  • Mark a file reviewed and its header turns green while the next file glides in.
  • Changed your mind? Un-reviewing runs git reset on that file, after asking, because it is a real edit to your staging area.
  • What you have reviewed is read from git every time, with git diff --cached, so there is no database to drift or migrate.
  • A file is reviewed when it is fully staged, so the state survives quitting the app, switching machines, or never opening it again.

Make it easy on your eyes

Five themes, each with its own lightness and contrast, applied before the first paint. System follows your computer, and you choose which light and dark theme it uses.

Capture and organise

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 your agent when you’re ready.

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.

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.

Work with your agent

Add Changeset to your agent

Changeset serves its threads over MCP, so your own agent works them from any terminal. Open the Work in your agent menu in any thread’s header and copy the connect line. Paste it into a terminal once; the line carries no secret.

Connect: sign the session in

The second line signs the session in. Changeset asks you, in its own window, whether to let it work your threads, and shows a code: check that the code on screen matches the one on your browser’s sign-in page before you approve. Connected sessions can be managed and disconnected in Settings at any time.

Install the skill once, and your agent keeps up

Without it, a session hears your reply only when it next uses Changeset. Install the changeset-threads skill once: the Work in your agent panel, in the thread’s header, gives you the setup prompt to copy, and you paste it into your agent. Start it, and your agent waits for your replies and works each one as it arrives, until you tell it to stop.

Keep it checking for your replies

With the skill installed, the Work in your agent panel’s last setup step copies one more prompt to paste into your agent. It checks your threads at once and sets itself to check again every few minutes, using its own loop. Switch a thread to Active and reply there: the line in its header says an agent is picking it up, and the waiting agent answers on its own.

Leave a note for your agent

Press the + beside any line of the diff, or add a note on a whole file, and write what you want in your own words. Tag it if you like, and save: the note becomes a thread. Unless you switch Active on as you save it, it starts off, and agents leave it alone.

Activate a thread

Activate is a switch in each thread’s header that only you can set. When it’s on, a session waiting on Changeset picks the thread up, and the line under the switch says your agent is on it; when it’s off, agents leave the thread alone: one you point at it can read it, then asks you to switch it on. Resolving, archiving or pressing Stop switches it off.

Hand a thread to your own agent

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

See what your agent is doing

Your agent works through Changeset’s tools, so its progress shows in the thread and doesn’t scroll away in a terminal. A status card says what it is doing and how far along it is, and Stop asks it to stop.

  • Your agent reads the diff you are reviewing, including which files you have already reviewed.

Nudge it

A session hears your reply only when it next uses Changeset. When your reply waits on an agent that hasn’t read it, the thread’s status card offers Copy nudge: paste the line into that agent’s terminal, and it reads your reply now.

Quick replies, one tap away

Quick replies, one tap away: a few come built in, and you add your own. Tap Status? under the reply box and it is sent at once; the + at the end of the row adds another, and Settings, under Replies, edits the list.

It claims files before editing

A session claims the files it is about to edit, so two sessions don’t edit the same file at once; a second one waits its turn. Its status card says which file it is waiting for, which thread holds it and when it gives up, and it carries on by itself once the file is free.

It opens threads for what it notices

If you allow it in How I work on the rail, it can open a new thread for something it noticed along the way. Agents may open threads, under What agents may do in Changeset, is that setting; with it off, an agent raises a new point in the thread it is working instead. Any session you connect can file notes into your backlog, see what’s still open and pick a thread up, in the repositories you trust.

Settle it before it’s built

Ask for a plan, the test cases and a mockup before any work starts. Your agent 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.

Pick from mockups, not descriptions

Ask for a mockup, a diagram or an icon and it lands in the thread, not in your scrollback. When a choice can be drawn, your agent offers pictures: enlarge one, press Pick, and that is the decision. A revised mockup is kept as a new version, and everything stays with the thread.

Ask for artifacts

Ask your agent for any of these, and it arrives in the thread, ready to open in Changeset: documents and reports get a button of their own in the thread’s header, and pictures and links gather under Artifacts. Ask again and it comes back as the next version, and everything stays with the thread long after the terminal it came from is gone.

  • Plan: how the work will go, for you to approve before anything is built.
  • Spec: what the work will be checked against, the tests it has to pass.
  • Summary: what was actually built, kept up to date as the work moves.
  • Decisions: the points your agent needs you to settle, answered one by one in one window.
  • Mockup: a picture of a screen, to judge before it’s built; press Pick and that’s your choice.
  • Diagram: a drawing of how something works.
  • Image or icon: a picture made for your project.
  • Report: a written finding, such as a security review, an audit or some research.
  • File: anything else your agent made, kept with the thread.
  • Link: a web address worth opening.

Decide before it’s built

Never lose a decision again

In a terminal, the questions your agent 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 your agent proposes, in the thread’s Decisions window.

  • 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 your agent to write the approved ones into your project, word for word, and each decision then shows the file and line it went to.

Boundaries

What it will never do to your code.

Your files
Never unasked. Reviewing only ever writes the git index. Your agent 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 your coding agent: when you ask it for something, what it reads goes to its provider.

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.

Agents. Changeset’s threads are worked by a coding agent you run yourself, connected over MCP. When we say agents, we mean the ones Changeset is tested with for now: Claude Code, and Antigravity with Gemini. Others that speak MCP may work, but aren’t tested yet.

  1. 1

    A coding agent

    For the agent features

    One you run yourself, installed and signed in, such as Claude Code. Changeset connects to it over MCP, and every thread it works runs in your own session.

  2. 2

    Your agent’s subscription

    For the agent features

    Your own, with your agent’s provider, such as Anthropic for Claude Code or Google for Gemini, billed separately. Changeset neither includes nor resells it.

  3. 3

    git

    Required

    Installed and on your PATH. Changeset runs the copy already on your computer.

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

Changeset’s MCP server speaks revision 2026-07-28 of the Model Context Protocol, and still serves 2025-11-25 and 2025-06-18 for clients that haven’t moved to it yet.

Get it

$19.95, one-time purchase

Changeset goes on sale here soon.

No subscription. You own that version, forever.

Available for Windows and Apple Silicon.

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

Your agent’s subscription is required for the agent features

They run on your own subscription with your agent’s provider, billed separately. 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.

Windows & Apple Silicon · runs on your own machine · borrows only your coding agent and git from your system

We collect anonymous page analytics to improve the platform. Privacy Policy