Hunk vs Plannotator
Both tools exist because a coding agent writes more code than you can comfortably read, and they answer it in different places. Plannotator runs a local server and opens the review in your browser. It also covers agent plans before any code exists, plus GitHub pull requests and GitLab merge requests by URL. Hunk keeps the review in the terminal next to the agent that wrote the change, with its reasoning rendered beside the hunks it explains. Pick by where you want to be reading.
Which to choose
Choose Hunk if
- You want to stay in the terminal, including over SSH or in a remote tmux with no browser.
- You want the agent's reasoning rendered in the diff, attached to specific hunks.
- You want the agent to read and navigate the review session you have open.
- You also want a general diff viewer for ordinary Git work, pager and difftool included.
Choose Plannotator if
- You want to review the agent's plan before it writes any code.
- You prefer a browser UI, with wider text, images, and rendered Markdown.
- You want to review a GitHub PR or GitLab MR by pasting its URL.
- You want AI reviews built into the tool, posting comments on the diff for you.
- You work in Perforce or GitButler.
The problem they share
When you wrote the code, reading the diff was a formality. When an agent wrote it, the diff is the only place you find out what actually happened, and the volume went up at the moment your context went down.
Both tools answer with a review surface that talks back to the agent. You mark something up and your feedback returns to the agent session as structured input instead of a message you retype. The difference is where the reading happens and how early in the loop it starts.
What Plannotator does
Plannotator runs a local binary that starts a temporary server and opens the session in your browser. What it leads with is plan review. When an agent proposes a plan, that plan opens for annotation before any code is written, and you can comment, redline, mark up, and label inline, then approve or send structured feedback back to the agent.
Its code review surface handles local changes across Git, Jujutsu, Perforce, and GitButler, and it can open a GitHub pull request or GitLab merge request from a URL. It has AI review built in, so it can answer questions about what you are reading and launch reviews that post their own comments on the diff. It integrates with a long list of agents through host-specific hooks and commands, and it is dual-licensed under Apache 2.0 or MIT. Plans, diffs, and annotations stay local by default.
If reviewing plans before implementation is part of how you work, or you want hosted PRs and built-in AI review in the same tool, those are real capabilities Hunk does not have.
What Hunk does
Hunk stays in the terminal. Run hunk diff in a second pane and it renders every visible file as one continuous review stream with a sidebar, split or stacked layouts, syntax highlighting, mouse support, and --watch to reload as the agent keeps working.
The agent-facing part runs the other direction from a comment box. Each session registers with a local loopback daemon, and the agent uses non-interactive hunk session commands to inspect the review you are looking at, navigate it, and leave notes. hunk session review --json gives it the structure of the changeset without pushing the whole patch into its context. Its reasoning then renders inline as note cards on specific hunks, so the explanation sits next to the code instead of in a separate transcript.
Hunk is also an ordinary diff viewer. The same binary is your Git pager, difftool, patch reader, and two-file comparison tool, which matters if you would rather not install a second thing for non-agent work.
curl -fsSL https://hunk.dev/install.sh | sh
# terminal 1: your review, stays open
hunk diff --watch
# terminal 2: point the agent at the review skill
hunk skill pathChoosing
Take Plannotator if the plan is where you most want to catch problems, if you would rather read in a browser, or if you need Perforce, GitButler, hosted PR review, or built-in AI review in the same tool.
Take Hunk if the diff is what you review, if you want the agent's reasoning rendered in the diff rather than alongside it, if the agent should be able to read and drive the session you have open, or if you want one terminal tool that is also your everyday Git pager and difftool.
They are not exclusive. They hook into agents at different points, so nothing stops you annotating a plan in one and reviewing the resulting diff in the other.
Hunk vs Plannotator, capability by capability
Plannotator is written in TypeScript and licensed Apache-2.0 or MIT. Hunk is TypeScript, MIT, and ships as a standalone binary for macOS, Linux, and Windows.
| Capability | Hunk | Plannotator |
|---|---|---|
| Reviews agent plans before implementationPlan review is what Plannotator leads with. Hunk starts once there is a diff. | No | Yes |
| Reviews local code changes as a diff | Yes | Yes |
| Terminal-native UIPlannotator is browser-first. A separate terminal annotator ships as a Herdr plugin and as a standalone TUI, for documents rather than diffs. | Yes | Partly |
| Browser UIHunk's review surface is a terminal UI. | No | Yes |
| Works with no browser availablePlannotator opens a local server and a browser tab to reach it. | Yes | No |
| Line-level comments returned to the agent | Yes | Yes |
| Built-in AI review that posts its own commentsPlannotator can launch AI reviews that comment on the diff and answer questions about it. Hunk relies on the agent you already have. | No | Yes |
Agent can read and drive the live review sessionPlannotator exposes WebMCP tools on its plan and annotate surfaces to a WebMCP-capable browser, not on its diff review. Hunk's hunk session works from any shell against the diff review itself. | Yes | Partly |
| Reviews a GitHub PR or GitLab MR by URLHunk reviews local working trees, commits, patches, and file pairs. | No | Yes |
| Git | Yes | Yes |
| Jujutsu | Yes | Yes |
| Sapling | Yes | No |
| Perforce and GitButler | No | Yes |
General-purpose Git pager and difftoolHunk also stands in for core.pager and git difftool on ordinary, non-agent work. | Yes | No |
Watch mode that reloads the reviewPlannotator polls the repo while a review is open and offers a Refresh when the working tree moves. Hunk's --watch reloads the review itself. | Yes | Partly |
| Split and unified layouts switchable mid-reviewPlannotator toggles Split and Unified from its settings panel. Hunk adds a responsive auto layout and switches from the keyboard. | Yes | Yes |
| ThemesHunk ships 65 bundled themes and takes custom ones. Plannotator ships its own set, chosen in its settings panel. | Yes | Yes |
| Third-party extension APIMeaning third-party code that extends the review UI itself. Plannotator has agent integrations, editor extensions, and custom review skills, but no such API. | Yes | No |
| Data stays on your machinePlannotator is local by default and is building a separate hosted product, Workspaces, for team sharing. Hunk has no hosted component. | Yes | Yes |
● yes · ◐ partly, see the note · ○ no
Questions people ask
Does Hunk review agent plans like Plannotator does?
No. Hunk's review starts once there is a diff: a working tree, a commit, a patch, or a file pair. Plan review before implementation is Plannotator's territory.
Can Hunk review a GitHub pull request?
Not from a URL. Hunk reviews local input: working trees, commits and revsets, patches on stdin, and file pairs. You can check out the PR branch and run hunk diff main...HEAD, but there is no PR-by-URL mode.
Which works better over SSH?
Hunk, because it never needs a browser. It is a terminal UI, so a remote shell or a tmux session on a server is a normal place to run it. Plannotator documents SSH and devcontainer setups, auto-detecting SSH and switching to a fixed port you forward, but the reading still happens in a browser on some machine.
Do both send my code anywhere?
Neither, by default. Hunk runs locally with a loopback daemon for session control and has no hosted component. Plannotator keeps plans, diffs, and annotations local by default, and is separately building a hosted product, Workspaces, for team sharing.
Which agents does each support?
Plannotator ships host-specific hooks and commands for a long list of agents, including Claude Code, Codex, Copilot CLI, Gemini CLI, and OpenCode. Hunk is agent-neutral: any agent that can run shell commands can use the hunk session surface and load the skill returned by hunk skill path.
Sources
Claims about Plannotator were checked against its own documentation in September 2026. If something here has gone stale, open an issue and it gets fixed.