Reviu is a native desktop app for reviewing agent-written code before you push. Run Claude Code, Codex, Gemini and other ACP agents in durable sessions, inspect every diff, send comments back to the agent, then stage, rebase, commit, open PRs and review GitHub pull requests without leaving the app.
Since the first launch, Reviu was rebuilt from a Git client with an agent panel into a review workspace for coding agents. Run Claude Code, Codex, Gemini, and other ACP agents in durable sessions, inspect every diff, send inline comments back, checkpoint or undo turns, and finish the branch with real Git. Pro adds GitHub PR review, checks, merge, and notifications.
The per-turn diff receipt is exactly the right idea. When an agent changes code across several files, reviewing turn by turn instead of one big squash diff catches things you'd otherwise miss. Sending a comment straight back to the agent with file and line context closes the loop without leaving the app.
What needs improvement
Would love the GitHub layer in the free tier, and a heads-up when a later turn edits a file I already marked as reviewed.
vs Alternatives
I already review agent-written code in Cursor and plain git diffs. Reviu stands out because the review is the product, not a panel bolted onto a chat, and the diffs are tied to agent turns rather than the whole branch.
Thanks Fredric, really appreciate it! The “later turn touched something I already reviewed” case is exactly the kind of boundary Reviu is meant to make visible. GitHub in free is tougher because of API/auth/maintenance costs, but I want the local review loop to stay strong without Pro
Hey Product Hunt - Joris here, maker of Reviu.
This is my second launch. The first version was a native Git/GitHub client with an agent panel. After using it myself, I realized the important workflow was not just chatting with an agent, or rebuilding GitHub on desktop. It was the review loop after an agent changes code.
So I rebuilt Reviu around sessions.
Each session is tied to a project and checkout. Agents can run in isolated worktrees, their tool calls and file changes stay visible, and each turn ends with a diff receipt. You can comment on exact lines and send those comments back to the agent with file and line context. Checkpoints let you undo a turn or edit an earlier prompt without messing with HEAD or staged changes.
The free app includes agent sessions, local diff review, worktrees, checkpoints, editor/terminal, and local Git workflows. Pro adds the GitHub layer: PR review, checks, merge, notifications, and browser handoff.
I built this because I trust agents more when the boundary is clear: code the agent wrote vs code I actually reviewed.
Report
@joris_gallot The diff receipt after every turn is my favorite part. Being able to comment on one exact line and send it back to the agent with the file and line attached is so much better than typing "fix that thing in the function" ....
"checkpoint or undo turns" is the feature I actually want - I've had claude code sessions where turn 4 did something I wanted to keep but turn 7 went off the rails and I had to manually untangle which file changes belonged to which turn. question on the undo though: if a turn already ran a shell command with a side effect outside the repo (hit an API, wrote to a db, pushed somewhere), does undo just revert the file diff and leave you to clean up the side effect yourself, or does it track that boundary too
@galdayan Great question, checkpoints are repo-state only: Reviu snapshots the working tree before the turn, then undo restores those files. It does not reset HEAD, staged changes, APIs, DB writes, pushes, etc
@joris_gallot that makes sense as a boundary, but it means the diff receipt can show a clean undo while a db write or an api call from that same turn is still sitting out there live. is there any surfacing of that at all, even just a warning like "this turn also did X outside the repo, undo won't touch it" or is it on the human reviewer to remember which turns had side effects before hitting undo
Report
The per-turn diff receipt is the right primitive. Our worst agent-written bug was a spend function that looked fine in the diff, it was writing bad balance events that only surfaced three tables away, and we missed it because we reviewed the whole branch squashed instead of turn by turn. The thing I'd want to know is what happens when a later turn edits a file I already marked reviewed. If it silently stays green, the boundary you're describing leaks.
@asadmalik901 Yes, that's the boundary I care about too, "Reviewed" should mean this version of this change was reviewed. If a later turn edits those lines again, it needs to show up as reviewable again instead of staying silently green
Thanks Fredric, really appreciate it! The “later turn touched something I already reviewed” case is exactly the kind of boundary Reviu is meant to make visible. GitHub in free is tougher because of API/auth/maintenance costs, but I want the local review loop to stay strong without Pro