A development environment for Claude Code

Twelve prompts.
One clean commit.

Kwizmo Plynth is the application you sit in while an agent works on your code. It runs on your machine, drives Claude Code across your repositories, records what every prompt changed, and lets you keep only the parts you want — underneath your git repository, without ever touching it.

Request access See how it works

Windows, macOS, Linux· Runs entirely on your machine· Stores no credentials

  1. Point it at a folderAny repository, or one that has never seen git
  2. Describe the changeClaude Code does the work, in a scratch copy first
  3. Keep what is rightRead it, check it, take parts back out, then commit
The Plynth timeline: prompts numbered and colour-coded, one failing its checks with the PHP parse error shown, one tagged as a hand edit, two prompts queued, and a notice that the next message will tell Claude what was rejected.

The problem

By the time you commit, it is one undifferentiated diff

Agents are fast enough that an ordinary session produces a dozen changes before anything is committed. Git cannot help you: none of it exists in history yet.

You cannot tell what did what

Five prompts touched the same file. Which one added the line you are staring at?

Undo is all or nothing

The third prompt went wrong, but the ninth built on top of it. Now you are unpicking both by hand.

Good work gets thrown out with bad

Four fifths of that change was right. Rejecting the whole prompt means asking for the good part again.

Your own edits get overwritten

You fixed a line by hand. The agent still believes it wrote something else there, and quietly puts it back.

Every prompt, on its own

A timeline you can actually read

Each prompt becomes a numbered entry, coloured by what happened to it. Open one and you get the model's summary, the tool calls it made, the checker's output and a line-numbered diff of what that prompt — and only that prompt — changed.

  • Checks run automatically after every prompt
  • A red entry offers Ask Claude to fix, with the error attached
  • Files you marked off limits are flagged before you commit
  • Anything you edited by hand is kept separate, and credited to you
Timeline entries: one passing its checks, one tagged as a hand edit, and one failing with the PHP parse error shown beneath it.

Keep what is right

Approve a change hunk by hunk

By default a prompt runs in a throwaway copy of your repository — nothing on disk changes until you say so. You get the diff split into individual hunks and tick the ones you want.

  • Take three edits and leave the fourth
  • Pull one change back out of a prompt that already landed
  • Neighbouring hunks and other prompts stay exactly as they are
  • Say why, and it becomes a standing rule in your CLAUDE.md
Review dialog: three files, each hunk with its own checkbox and diff, and a box asking why the change is being dropped.

Something git cannot do

Blame that names the prompt

Pick a file and see which request produced each line — including work you have not committed, where ordinary git blame has nothing to point at.

  • Three weeks later, "why does this exist" has an answer
  • Bisect across prompts to find the one that broke it
  • Search every prompt by wording or by the file it touched
  • Replay a sequence of prompts into another repository
Blame: most lines marked as committed, with individual lines attributed to the prompts that added Slovenia and Croatia.

A question one diff cannot answer

Compare any two points

One prompt, or everything since the last commit, with nothing in between — that was the gap. Pick the start of one prompt and the end of another and see what the whole feature changed, however many prompts sit between them.

  • Every snapshot is a real commit, so the range already exists
  • Undo a single file out of a prompt and leave the rest of it
  • Queue prompts and walk away — they run one at a time, in order
  • Export a sequence as a file and run it in another repository
Compare dialog: from the start of prompt one to the end of prompt five, six files listed with their line counts, and the combined diff below.

Look at it, then ask about it

The composer follows you

Read a file, spot the problem, ask about it — without leaving the file. The composer sits on every tab and collapses to one line where the code needs the room.

  • Syntax highlighting for 62 file extensions, no CDN, no npm
  • Ctrl+Enter opens it with the file's path already in the prompt
  • Anything you save here is recorded as yours, and described to Claude
  • Ctrl+K to switch repository, Ctrl+1..6 for views
The editor: a file list, highlighted PHP, and the composer collapsed to a single line reading Ask about includes slash countries dot php.

How it works

One decision, and the rest follows

Before and after every prompt, Plynth writes your whole working tree into git's object database using plumbing commands and a throwaway index. Those snapshots are real commits on a private ref.

GIT_INDEX_FILE=<tmp>  git read-tree HEAD
GIT_INDEX_FILE=<tmp>  git add -A
GIT_INDEX_FILE=<tmp>  git write-tree      -> tree
git commit-tree <tree> -p <previous>      -> commit
git update-ref refs/kwizmo/snapshots <commit>
Because they are git objectsYou get
git diff before afterthe exact diff for one prompt
git blameblame that names the prompt, not the commit
the commits already existbisect across prompts
git apply --cachedcommit some prompts and not others
a ref keeps them reachablenothing is ever garbage collected

git status, git log, your branch and your staging area are never touched. Remove Plynth and your repository is exactly as you left it.

Also included

The rest of it

Your edits are protected

Every hand edit is described to Claude before your next request, with an instruction not to restore an earlier version or rewrite the file.

Variants

Run one prompt up to four ways at once, each in its own copy, and compare the results before adopting one.

Selective commit

Untick prompts and the commit is rebuilt from the rest. The schema change need not ride along with the UI change.

Commit messages

Written from the prompts you actually sent. You described the change before making it; that beats guessing from a diff.

Secret scanning

Private keys, cloud credentials, tokens and database URLs with passwords are caught before the commit, not after the push.

Folders without git

Not a repository? Plynth tracks it anyway, keeping the history outside your files. No .git, no marker, nothing added.

Built-in editor

Syntax highlighting for 62 file extensions, so a two-line fix is something Plynth knows about the moment you make it.

Recipes

The prompt you run every month with one word changed, saved with placeholders and reusable across repositories.

Costs and search

What you have spent, how long you waited, which files the agent keeps returning to, and every prompt you have ever sent.

It tells you when it is done

A prompt takes minutes. Tab away and the browser tab title changes and a notification arrives, saying whether the checks passed.

Undo, and put back

An undone prompt keeps a button to restore it. Claude is told the change has returned, since it was told it had gone.

Branch aware

Checking out another branch rewrites half the tree. Plynth marks it as a new section rather than mistaking it for an enormous hand edit.

Thread weight

How many prompts the current conversation carries, and what it has cost. Long threads cost more and answer worse; now you can see it.

Requirements

Three programs, no dependencies

Plynth ships as a single folder and depends on nothing beyond what is listed here. There is nothing to compile, nothing added to your project, and nothing to undo if you stop using it.

Locked-down machine? The paths to git and Claude Code can be set in the interface or through environment variables when PATH cannot be changed.

What it is not

Under the hood

Built to be trusted with a week of work

244tests against real git repositories
0third-party dependencies
0bytes leaving your machine
62file types highlighted

Nothing is mocked. Every test runs against a real git repository, because a tool whose job is to protect your code has to be held to the behaviour and not to a stand-in. They concentrate on the places where a silent break would be expensive: that snapshots never touch your branch, that undo restores binary files byte for byte and refuses cleanly when it cannot, and that pulling one hunk out of the middle leaves its neighbours untouched.

See it on your own repository

Plynth is a commercial product. Get in touch and we will set you up with a licence and walk through it on a codebase you actually care about — which is the only way to tell whether it earns its place.

We reply from a person, usually within a working day or two.

  1. Tell us what you work on. Languages, roughly how many repositories, and whether they are under version control.
  2. We send you a licensed build. One folder. No installer, nothing added to your projects, nothing to undo if you stop.
  3. Point it at one repository and send a single prompt as a dry run. Then undo it, so you have watched the safety net work.
  4. Decide after a week of real work. That will tell you more than any feature list, including this page.