AI coding agents write code faster than humans can review it. That is the bottleneck Stage is built for. Stage CLI is an open source tool from ReviewStage that organizes your local code changes into logical chapters, adds a prologue and risk context, and opens a browser UI where you review the story of a change, file by file, instead of scrolling through one giant diff. It runs entirely on your machine and, as the README puts it, does not upload your source code.
Key Takeaways
Stage CLI organizes local changes into logical chapters with a prologue and risk context, so a review reads like a story instead of a wall of diffs.
It runs locally and opens its review UI in your browser. The README states it does not upload your source code.
Install it with npm install -g stagereview, add the agent skill with npx skills add ReviewStage/stage-cli, then run /stage-chapters in your AI agent.
You can scope a review with flags for base ref, compare ref, staged or unstaged changes, or a GitHub pull request by number or URL.
Comments left in the UI can be handed back to your coding agent with /stage-resolve, which fixes or answers them and marks the thread resolved.
At the time of writing it has 275 stars, 30 forks, and 92 commits on GitHub, it is MIT licensed, and it was created on 2026-04-26.
The founders claim reviews are 5 times faster with Stage, but that is a founder claim from their launch post, not an independently verified measurement.
Watch the 30-second repo signal
What Stage Actually Is
Stage, by ReviewStage, describes itself as "a viewer for reviewing local code changes in small individual chapters" that "works with any AI agent". In plain terms, it is a command line tool plus a local browser UI, not a hosted review service and not a review bot. You run it against your own working tree, and it groups related changes into chapters, explains what to look at before you dive into the code, and gives you a file-by-file surface with inline comments.
That distinction matters. Tools like CodeRabbit and Greptile review pull requests for you, automatically. Stage takes the opposite position, which its founders spelled out in their Show HN post: it guides you through reading a change step by step, rather than replacing the human reviewer. The agent is involved, but on your terms. You review, you leave comments, and only then does the agent act on them.
The project is young. It was created on 2026-04-26, and at the time of writing it has 275 stars, 30 forks, 92 commits, and 5 open issues, with no releases yet. Those numbers describe an early stage project with real traction, not a settled standard, and that is the right frame for judging it. It is also a Y Combinator Spring 2026 company, launched publicly on 2026-05-20 according to its Y Combinator launch post.
Why Reviewing Diffs Feels Like Work
A diff is a bad reading format. It shows you what changed, line by line, in file order, with no sense of why the changes belong together. When a change touches ten files, the diff interleaves a refactor, a bug fix, and a test update, and the reviewer has to reconstruct the author's intent from fragments. When an AI agent wrote the change, the problem gets worse, because the agent does not get tired, does not stop at a natural size, and does not explain itself unless asked.
Stage's answer is narrative structure. Instead of one flat diff, it produces chapters, each covering one logical piece of the change, plus a prologue that sets the scene and risk context that flags what deserves extra attention. You still see every line, but you see it in an order that matches how the change was meant to be understood. The UI supports full-file previews, image diffs, syntax themes, typography settings, continuous chapter review, and keyboard navigation, so the reading experience is closer to reading a document than to scrolling a terminal.
There is a second, quieter benefit. Because Stage runs locally, reviewing a messy work in progress does not require pushing a branch, opening a pull request, or waiting for a hosted tool. You can review half-finished work, untracked files included, before anything leaves your machine.
How Chapters Work
The workflow has three steps. Install the tool, add the skill to your agent, and run one command.
Step | What you run |
|---|---|
Install | npm install -g stagereview |
Add the skill | npx skills add ReviewStage/stage-cli |
Review | /stage-chapters in your AI agent |
The requirements are modest: Node.js 20 or newer, a Git repository to review, and an AI agent that supports skills. If you want to review GitHub pull requests, you also need the GitHub CLI, gh, installed and authenticated.
Once it runs, Stage organizes your changes into chapters and opens the review UI in your browser. Everything happens on your machine. The review surface itself is where the tool earns its keep.
Feature | What it gives you |
|---|---|
Chapters | Related changes grouped into logical, reviewable pieces |
Prologue | An overview that sets up the change before you read code |
Risk context | Pointers to what deserves attention before you dive in |
File-by-file review | A guided path through the change, one file at a time |
Inline comments | Leave notes directly on the diff in the browser |
Full-file previews | See the whole file, not just the changed lines |
Image diffs | Visual comparison for changed images |
Keyboard navigation | Move through chapters and files without the mouse |
Two details show the tool was built by people who review a lot of code. First, a .stageignore file, using gitignore-style patterns, excludes files from diff analysis, but ignored files still appear in an "Other changes" chapter, so nothing is silently hidden. Second, a .stageinstructions file in the repository root gives persistent review guidance, such as project conventions or areas that deserve extra attention, and a one-off --instructions flag (up to 1000 characters) covers a single run.
Scoping a Review With Flags
A review tool is only useful if you can point it at exactly the change you mean. Stage's flags cover the cases that come up in daily work.
Flag | What it does |
|---|---|
--base | Base ref to diff against, auto-detects main or master by default |
--compare | Compare ref to diff against the base ref |
--ref | Diff scope: work (staged plus unstaged plus untracked), staged, or unstaged |
--pr | Review a GitHub pull request by number or URL, requires gh |
--instructions | One-off instructions for chapter generation, up to 1000 characters |
In practice that means you can review only staged changes with /stage-chapters --ref staged, diff against a specific branch with /stage-chapters --base feature-a, compare two branches with /stage-chapters main feature, or review a teammate's pull request with /stage-chapters --pr 123, without checking out their branch. For pull requests, Stage loads the change and exposes its review timeline, comments, labels, viewed-file state, merge status, and stacked pull request navigation when available, while actions like submitting comments or merging stay subject to your GitHub permissions.
From Comment to Fix, Without Leaving the Review
Reviewing is only half the loop. The other half is getting fixes made, and Stage closes that loop with a second skill. Leave comments on the diff in the Stage UI, then hand them to your coding agent with /stage-resolve. The agent reads every open thread, makes the requested change or answers the question, and resolves the thread with a short summary. Its replies show up in the browser automatically with an "Agent" badge. Pass the same refs or --pr flag you used for the review, so the agent looks at the same diff.
Under the hood, this uses the stagereview comments commands, which work without the review server running: list open threads, show one thread in full, reply, resolve, reopen, or create a comment on a specific file and line range. That is a practical design choice. The review UI is for reading, the agent is for acting, and the comment thread is the contract between them. You never have to copy a comment into a chat window or re-explain which lines you meant.
The Hosted Stage, and What the CLI Costs
Stage CLI is the open source part of a larger product. The full Stage platform, at stagereview.app, turns every pull request into a story you can follow, with the same chapter idea applied to hosted review. Its pricing page lists a Starter plan that is free for open source and public projects with unlimited public repositories, a Team plan at 30 dollars per user per month for private repositories, and a custom Enterprise plan. The FAQ states Stage is completely free for open source repositories with no time limit.
The CLI itself is MIT licensed and free, and its local-first design means the hosted pricing does not gate the core workflow. If you only review local changes, you pay nothing and send nothing anywhere. The hosted product matters if your team wants the same story format on pull requests, with shared timelines and comments, rather than on local diffs alone.
Who Should Try It, and Who Should Wait
Stage CLI makes the most sense if you already review AI-generated code, or large changes, and you feel the pain of flat diffs. If your agent regularly produces multi-file changes, if you review before pushing rather than after opening a pull request, or if you want a human in control of the review while still letting the agent do the fixing, the chapter format is a genuine improvement over scrolling a diff. The local-first design also fits if you are careful about where your source code goes.
You should probably wait, or keep expectations modest, if you want a fully automated reviewer, if your team relies on a hosted review workflow with approvals and merge queues, or if you need a mature tool with releases and a long track record. Stage CLI has no releases yet, its 275 stars reflect early adoption, and its headline speed claim comes from its founders, not an independent benchmark. Try it on one real change, compare the chapter review against your usual diff scroll, and judge it by whether you caught something you would have missed.
If you work in the same AI coding world, the site has a related spotlight on a tool that tracks exactly which lines your AI agent wrote: Git AI: Track Exactly Which Lines Your AI Coding Agent Wrote. Stage CLI helps you review what the agent changed, and Git AI helps you prove which lines the agent wrote in the first place.
Frequently Asked Questions
Is Stage CLI a code review bot?
No. It organizes changes into chapters and guides you through reading them. It does not approve, reject, or auto-fix code on its own. The agent only acts on comments you leave, through /stage-resolve.
Does Stage upload my source code?
No. The README states Stage runs locally and does not upload your source code. The review UI opens in your browser, but everything happens on your machine.
How do I install it?
Run npm install -g stagereview, then add the skill with npx skills add ReviewStage/stage-cli. It requires Node.js 20 or newer, a Git repository, and an AI agent that supports skills.
Can I review a pull request without checking out its branch?
Yes, with the GitHub CLI installed and authenticated. Run /stage-chapters --pr followed by the pull request number or URL, and Stage loads the change, its timeline, comments, labels, and merge status.
Is Stage free?
The CLI is MIT licensed and free. The hosted Stage platform is free for open source and public projects, with a Team plan at 30 dollars per user per month for private repositories.