Introducing Reviu 1.0: The Review Workspace for Coding Agents

I started Reviu as the Git client I wanted to use: native, fast, and designed around the keyboard. By version 0.18 it covered a lot of ground. It had a complete local Git page, several GitHub pages, pull request review, and an agent panel for Claude and Codex.

The agent panel worked, but it exposed a problem with the rest of the app. I could ask an agent to change something, review its diff, and send comments back, yet the session was still treated as an accessory to the Git page. Opening another repository changed the context around it. Moving between the conversation, files, terminal, local changes, and pull request meant moving through surfaces designed before the agent existed.

I first tried to improve that arrangement. The more I worked on it, the clearer it became that another panel or shortcut would not fix the underlying shape. The session had to become the thing the rest of the app was organized around.

A rewrite that started by deleting

The first pull request for this direction added the Sessions workspace and deleted almost 33,000 lines. Most of those lines belonged to the broad GitHub client: the GitHub home, repository browser, profiles, commit details, issues, and the old pull request pages. That was only the start.

During the following month I moved every local Git workflow into the new workspace, removed the separate Git page, and rebuilt the center of the app around tabs. Conversations, files, diffs, and terminals now use the same tab model. They can be reordered, restored per checkout, or dragged into resizable splits.

The result is one window with a stable layout. Projects and their checkouts are on the left. The work itself is in the center. Repository state stays in a dock on the right, where Changes, Files, History, Review, and Pull Request are always close without taking over the workspace.

The session now owns its context

A Reviu session is tied to a project and checkout. Selecting it points the file tree, diff, terminal, history, and branch controls at the same place. Its draft and reading position survive a restart, and the agent keeps running if you open another session.

For work that should not touch the main checkout, Reviu creates a Git worktree and branch for the session. Several agents can run at the same time without writing into the same working directory. Their status is visible next to the project, so I can move to another task without forgetting which process is working or waiting for permission.

Agents come from the official Agent Client Protocol registry rather than a fixed list maintained in Reviu. The app launches the CLI already installed and authenticated on the machine. I use Codex and Claude most often, but Gemini, Copilot, Cline, and the other registry agents go through the same session and review UI.

Reviewing the result is the important part

I do not need another chat window that hides what happened between the prompt and the final answer. While an agent works, Reviu shows its tool calls, commands, output, thinking, and permission requests in the conversation. When a turn changes files, it ends with a receipt that opens each diff and shows the number of lines added and removed.

From a diff I can comment on the exact lines I want changed. Those comments collect in the Review panel and go back to the agent with the file and line context intact. If the next turn rewrites those lines, Reviu marks the old comment instead of quietly losing it. I can also send a selection, attach a screenshot, queue the next message, or steer a turn that is already running.

Every prompt creates a checkpoint before the agent starts. Undo on a turn restores the files while keeping the conversation. Going further back restores the earlier working tree and trims the conversation to that point. Editing an old prompt uses the same mechanism, then starts again from the corrected instruction. HEAD and the staged state are left alone.

This part took much more work than placing a chat beside a diff, but it is also the reason Reviu exists. The useful boundary is not between the agent and Git. It is between code the agent produced and code I have actually reviewed.

Git remains visible

Rebuilding around sessions did not remove the Git client. The same workspace can stage individual hunks, amend and undo commits, switch branches, manage stashes, cherry-pick, resolve conflicts, inspect history, and run an interactive rebase. The project explorer edits and creates files, while the terminal keeps its scrollback, working directory, search, and links into the editor.

I want the agent to handle as much implementation work as I ask it to, but I still want to see the branch and working tree underneath. When something goes wrong, those are the tools I trust to understand and fix it.

Why GitHub became smaller

Reviu 0.18 tried to reproduce a large part of GitHub in a desktop app. It was expensive to maintain and most of it sat outside the daily path I was now building for. github.com already has good repository, profile, issue, commit, and discussion pages. Reviu did not need a second version of each one.

Reviu Pro now keeps the GitHub pieces attached to the branch being shipped. Its pull request appears in the right dock with changed files, comments, checks, reviewers, merge state, and the merge methods allowed by the repository. GitHub notifications remain in the sidebar. A link or the browser extension can bring a pull request into Reviu and check out its branch after confirmation; broader GitHub links open in the browser.

I also removed Reviu's OpenAI and Anthropic key settings, pull request briefs, and generated commit messages. The coding agent already has the repository, the diff, and the model subscription. Asking it for a summary or commit message is simpler than configuring a second AI path inside Reviu.

What ships in 1.0

The local workflow is free and needs no Reviu account: agent sessions, parallel worktrees, checkpoints, the editor and terminal, review comments sent back to the agent, and the full local Git toolset. Reviu Pro remains the paid GitHub layer for pull request review, checks, merge, notifications, and browser handoff.

Version 1.0 is a much smaller product idea than the one I was building before, even though the app can now do more around an agent session. It has one job: let the agent work, let me inspect the result properly, and keep the real repository close until the branch is ready to ship.