Code Review · Plannotator

Code review for
the modern era.

Plannotator opens a local diff viewer for git, jj, and Perforce. You annotate lines, tokens, or whole files, and when you're done the notes feed straight into your agent session — an automated feedback loop. It works on local diffs, commits, branches, worktrees, and GitHub/GitLab PRs. The core tool is manual; the AI layer on top is optional and answers to you. Free, MIT / Apache-2.0, with local review data kept on your machine by default.

git jj Perforce

custom reviews: Bring your own skills. They run in the background and leave findings as inline diff comments.

part one

The manual tool

Review any changeset with nothing between you and the diff. No model in the loop unless you put one there.

annotate → agent

Your annotations become the agent's instructions

Select lines, a single token, or a whole file, and leave a comment, a concern, or a suggested edit. Conventional Comments labels are there if your team reviews that way.

Hit Send Feedback and everything exports as markdown, anchored to exact files and lines, straight into your agent session. The agent reads it like any other instruction and gets to work.

Line, token, file, and review-level scopes
Suggested-code blocks with the original alongside
Drafts auto-save and survive a crashed session

git status view

Review the whole change before it's a PR

The default view pulls together everything you've touched — committed work, uncommitted edits, and untracked files — in one screen. No commit, push, or PR required; you see what a PR would show while the work is still in progress.

It's grouped the way git status groups it: Committed, Changes, Untracked. Every row shows the change type and line counts, and you can stage or unstage files right there while you review.

Falls back gracefully when no base branch resolves
One-click fetch when the base is behind GitHub

commits panel

Walk the branch, one commit at a time

The Commits panel is a plain history rail of your branch, newest first, with a divider where your work meets the base. Click any commit for its own diff against its parent, with the full commit message on top.

It's git show with annotations. Review a teammate's commit or your own from last Tuesday; the feedback records which commit each note was anchored to.

Session-scoped: glancing at history never changes your default view

pull requests

Review PRs without the noise

Point it at a GitHub PR or GitLab MR and it opens in the same viewer: description, checks, and the full discussion in one Overview panel. The comments column filters the noise — hide bots (Dependabot, CI, Copilot) with one toggle, drop resolved and outdated threads, narrow to specific people, or search the thread.

The description and comments are annotatable too. The agent can't see the discussion on its own, so your notes travel with the full comment quoted. Post your review back as inline comments, or hand it to the agent to fix.

Hide bots is on by default; resolved and outdated threads collapse away
Uses your gh / glab auth, so private repos just work
Stacked PRs get a Layer / Full-stack toggle for the whole chain

part two

The AI layer

Same viewer, same annotations, more eyes on the code. Agents flag; you decide what ships.

AI ask ai

Ask the diff a question

Select lines in the diff and ask. The answer streams into a side panel, scoped to what you selected and the changeset on screen, riding whichever agent CLI you already use.

It's reading support, not delegation — you stay in the diff while the model holds the context you'd otherwise go dig for.

Providers detected from the CLIs you already have installed
Answers stay grouped by file for the session

AI guided review

Let an agent chapter the changeset

A Guided Review has an agent reorganize the changeset into chapters by importance — the heart of the change first, then its consequences, then the glue (inspired by Linear). Each chapter pairs a short overview and per-file summaries with the diffs it covers. On a big diff it reads far better than file order.

The diffs inside a guide are the real diff viewer, not excerpts. You still read every line; the agent just orders them. Anything you annotate there lands in the same review and ships in the same feedback.

Per-section reviewed state for multi-sitting reviews
Every changed file validated against the real diff

AI agent reviews

Run review agents

Kick off a review agent against the current changeset; the selected AI provider receives the review prompt and relevant repository or diff context. Findings come back as annotations with a severity, reasoning, and a file and line anchor. Nothing is posted back to GitHub or GitLab until you choose to send the review.

The review is yours to define. Point it at one of your own skills — a security checklist, your naming conventions, whatever you've written — and Plannotator links to it locally and runs it as a launchable reviewer, findings landing inline like the built-in one. Runs on Claude or Codex natively, or through Cursor, OpenCode, Pi, and GitHub Copilot CLI when they're on your PATH.

Bring your own review skill; its findings land as diff comments
Code Tours: a narrated walkthrough with checkpoints
Run several engines on the same diff and compare findings

integrations

Agents can talk to it from the outside, too

There's also a local API. Anything outside the viewer — another agent, your CI, a linter, a script — can POST findings, markers, or notes straight onto the diff. They stream in live and land inline, tagged by source, right next to your own annotations.

part three

Compound engineering

Every annotation you make is saved to ~/.plannotator. Point an agent at that history and the feedback you keep repeating distills into a custom review skill — caught before you see it again.

You annotate

Every note is written to ~/.plannotator, review after review — a growing record of what you actually care about.

Distill a skill

Point an agent at that history. The feedback you give again and again becomes a custom review skill, in your own words.

It reviews for you

The skill runs as a review agent and leaves the note inline, on the diff — so the next agent gets it right the first time.

Two minutes to your first review

Install once and /plannotator-review works from Claude Code, OpenCode, Codex, Pi, Copilot CLI, Droid, and more.