Building Diffotator: Fork’s Interface, Plannotator’s Agent Loop

I have been spending more time than I expected reviewing code written by coding agents. The agents are fast, but reviewing their work in a terminal can make an important part of the process feel like a chore: finding the right file, understanding the surrounding change, and turning a thought into feedback the agent can act on.

That is why I built diffotator.

The tools that shaped it#

I loved working with Plannotator. It makes agent work feel reviewable: you can look at a plan or a diff in a proper interface, leave focused comments, and send that feedback straight back to the agent. The loop is clear, local, and practical. Comments are not lost in a chat transcript; they become part of the next step.

At the same time, I have always loved Fork’s interface. It is fast, calm, and built around the way I actually want to explore a repository. The commit history, file navigation, and diff view make Git feel like a place I can move through rather than a wall of commands.

I kept finding myself going back to Fork. That was the clue.

I did not want to choose between the two experiences. I wanted the powers of Plannotator inside an interface that felt more like Fork, so I made diffotator.

What diffotator does#

Diffotator is a local Git review client for coding-agent changes. It gives me a real surface for reviewing an agent’s work instead of asking me to parse a large terminal output.

• Browse changed files in a split diff view
• Move through a repository, commits, branches, worktrees, stashes, and tags
• Add inline comments to exact lines
• Use structured review labels such as issue, suggestion, nit, and question
• Mark comments as blocking when the agent must address them
• Include suggested code replacements
• Send the finished review back to Claude Code as Markdown
• Approve the work or close the review without feedback

The important part is the handoff. When I submit a review, the comments go back to the coding agent as actionable instructions. I can say what is wrong, where it is wrong, and what needs to change without copying context by hand.

A tighter agent loop#

The workflow is simple:

1. Let the agent make a change.
2. Open the diff in diffotator.
3. Review each file in a focused interface.
4. Comment on the lines that need attention.
5. Send the review back to the agent.
6. Let the agent revise the work.

There is also an optional Claude Code Stop hook. With it installed, diffotator can open a review when an agent turn leaves meaningful changes, then send blocking feedback back through the hook so the agent can continue working.

That turns code review into part of the agent loop rather than a separate task I have to remember later.

Local by design#

Diffotator runs against a local Git repository. It does not need a hosted review service, repository configuration, or project dependencies. The goal is a small, direct tool that sits close to the code and keeps the review in the same loop as the agent.

The project is open source and MIT licensed. You can explore it on GitHub, or try the project site at diffotator.vercel.app.

I built diffotator because I wanted Plannotator’s feedback loop and Fork’s way of seeing Git in one place. It is still growing, but the idea feels right: agents can move quickly, and we should have an interface that helps us stay thoughtful about what they produce.