Open sourceLocal-first · No account · Apache-2.0

The same agent that builds it helps you review it.

Comment on a line. It answers, and its fix lands in the diff you are still reading.

Works on a GitHub pull request too: diffo <PR URL>

Try a live review Star on GitHub

›Run `npx skills add DiffoHQ/diffo --skill diffo -g` and open the diffo review

The Diffo loop: in the agent's terminal you type /diffo and the review opens; your question on line 14 goes to the agent, which fixes the code and answers; the answer and the fix land in the thread and the diff.

Works with the agent you already build with

Claude CodeCursorCodexVS CodeCopilot CLIGemini CLIAmpGooseOpenCodeClaude CodeCursorCodexVS CodeCopilot CLIGemini CLIAmpGooseOpenCode

One round trip

Ask on a line. The fix lands in your diff.

localhost · feature/retry-backoff

3 files · +18 −6

UnifiedSplit

src/net/fetchWithRetry.tsViewed

12export async function fetchWithRetry(url: string, opts: RetryOpts = {}) {

13 const attempts = opts.attempts ?? 3;

14- const delay = 500;

14+ const base = opts.baseDelayMs ?? 250;

You

YouCHANGElines 14–19

A fixed 500ms will hammer the API when it's down. Can we back off instead?

Claude Codethe session that wrote this

I picked 500ms while testing locally. Switched to exponential backoff with jitter, starting at 250ms. Lines 14 and 19 are updated.

Fix landed in this diff · just now

15 for (let i = 0; i < attempts; i++) {

16 try {

17 return await fetch(url);

18 } catch (err) {

19- await sleep(delay);

19+ await sleep(base * 2 ** i + jitter());

20 }

21 }

Not an AI reviewer

You read. It answers.

It never grades the diff, never leaves nitpicks. It's the author, still in the room.

claude · sessionrunning 42m

✓ edited src/net/fetchWithRetry.ts

✓ added src/net/jitter.ts

✓ updated test/retry.test.ts

› remembers why: “API rate-limits at 10 req/s”

It wrote the code

Not a bot that read your diff afterwards. The session that made the change is still running, and it still remembers why it made it.

QUESTIONcache.ts:42Why a Map here, not an object?

Keys are user IDs and insertion order drives eviction. A Map keeps both.

It helps you review

Ask on any line and the answer comes back in your thread. It never grades the diff, never leaves nitpicks, never says anything is “fine”.

retry.ts+1 −1

for (let i = 0; i < n; i++) {

- await sleep(delay);

+ await sleep(base * 2 ** i);

Landed before the commit

On the spot

Ask for a change and the fix lands in the diff you are already reading. Before the commit, before the pull request, while it is still cheap.

Layers

Read it in layers, in the order it should be read.

A diff arrives alphabetically, which is almost never the order to read it in. Ask, and the agent posts layers: the change as ordered steps, each with a title, a summary and its files.

You read one at a time. Anything the agent touches after posting gathers in a Since your review layer, so nothing hides outside the plan.

How layers work

Layers in Diffo: the reviewer accepts the suggested layers; the agent outlines the 13-file change as four ordered steps; the layers land in the rail, the first layer draws its diagram, its files are read and ticked, and the next layer opens.

diffo <PR URL>

Pull requests too. Your agent reads beside you.

Hand it a pull request link. It opens in a worktree of its own, with its conversation imported and your agent beside you, even on code it did not write.

Comments for the author go to GitHub as one review when you finish. Questions for your agent never leave your machine.

Reviewing a pull request

A pull request in Diffo: the PR opens in a worktree of its own; a private question on line 13 goes to your agent, which runs the tests and answers in the thread; a PR comment waits as a draft until you submit the review to GitHub, while the private thread stays on your machine.

The loop

Writing code got a collaborator. Reviewing never did.

Ask what a hunk does and the agent that wrote it answers in the thread. Ask why, and it explains, with a diagram when the shape needs one.

It orients you

One guide comment on a big change: what it does, plus a mermaid diagram when the shape is easier to see than to read.

You read

Syntax-highlighted unified or split diffs, word-level marks, keyboard-first movement, per-file viewed tracking.

You comment

On a line, a range, a file, or the whole changeset. Each thread is a Change or a Question, so a question never turns into a refactor.

It answers, live

Answers land inline in your threads. Fixes land in the diff you're reading: the fix itself, not a promise of one.

Review with the agent that wrote it.

Paste one line into your agent. It adds the skill and opens the review. No account, and it runs on your machine.

Try a live review Star on GitHub

›Run `npx skills add DiffoHQ/diffo --skill diffo -g` and open the diffo review