Show HN: Code Review Environment for the Modern Era

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 code suggestion. Conventional Comments labels are there if your team writes reviews that way.

When you hit Send Feedback, everything exports as markdown anchored to exact files and lines and lands in 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 need to commit, push, or open a PR first, you see exactly what a PR would show while the work is still in progress.

It's grouped the way git status groups it: a Committed section, a Changes section, an Untracked section. 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 and you get that commit's 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, and 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 a GitLab MR and it opens in the same viewer: the description, checks, and full discussion in one Overview panel. On a busy PR the discussion is where you drown, so the comments column filters it down. Hide bots (Dependabot, CI, Copilot) with one toggle, drop resolved and outdated threads, narrow to specific people, or search the whole thread.

The description and comments are annotatable too. The agent can't see the PR discussion on its own, so your notes travel with the full comment quoted. Post your review back to the platform 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 the code 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; the model holds the context you would 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. 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 puts the lines in a smarter order. 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, keep the final say

Kick off a review agent against the current changeset and its findings come back as annotations on the diff, each with a severity, the reasoning behind it, and a file and line anchor. You decide what to keep. Nothing gets sent anywhere until you send it.

The review is yours to define. Point it at one of your own skills, your team's security checklist, your naming conventions, whatever you've written, and that skill becomes a launchable reviewer whose findings land as inline diff comments exactly 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

The AI you run inside Plannotator isn't the only thing that can touch a review. Through a small HTTP API, anything outside, another agent, your CI, a linter, a script, can POST findings straight onto the diff. They stream in live and land inline, tagged by where they came from, right next to your own notes.

part three

Compound engineering

Every annotation you make is saved to disk. Point an agent at that history, and the feedback you keep repeating turns into a custom review skill — caught before you ever see it again.

01

You annotate

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

02

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.

03

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.

the same feedback, caught automatically — never typed twice

Two minutes to your first review

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

Install Plannotator Read the docs