Local PR-review loop · human LLM

Review your branch like a PR. Hand the threads to your agent.

Run it in any git repo: leave inline comments on the diff, then hand the threads to your LLM acting as reviewer or reviewee via a bundled skill. Comments are plain JSON under .reviews/ — no clipboard handoff, no server required for the agent loop.

$ npx slop-review
Get started
0 runtime dependencies Node ≥ 20 browser or terminal node:http only
localhost:9410 — slop-review — feat/search-ranking
slop-review full-diff view: importance-ordered files, side-by-side diff with inline comment threads
One page, two renderers

In your browser. Or straight in your terminal.

The same keyboard-driven review UI runs as a local web app, and fully inside your terminal via Carbonyl — a Chromium fork that paints into the TTY. No window switch, no context loss. Nearly every keybinding carries over (two modifier chords use terminal-friendly substitutes).

Browser

The full GUI, zero setup

localhost:9410
slop-review per-commit diff in the browser
Terminal

--carbonyl keeps it in one pane

zsh — carbonyl
slop-review diff rendered inside the terminal via Carbonyl
Highlights

Built for the review loop, not just diff-staring.

Nine things slop-review does that a plain diff viewer doesn't.

01 / Importance-ordered files

Land on the load-bearing edits first.

Every diff sorts files by how central they are to the change set, not alphabetically. You start at the code that matters and walk outward to the tests and docs.

  • Incoming reference count: how many other changed files import this one
  • Then status (modified before added before removed)
  • Then source before support files (tests, docs, fixtures, configs), then path
localhost:9410 — full diff
Files sorted by reference count: parser.ts and types.ts first
02 / Vim keys + which-key hint bar

Drive the whole review from the home row.

Single-letter verbs handle comment, copy, deep-link, peek and delete, without leaving the keyboard. A which-key hint bar reveals on the first keypress and re-renders on every state change, showing only the keys live for your current row.

  • Hidden hints are strict no-ops, so the bar never advertises a dead key
  • j/k move, c comment, n next thread, r reviewed, p peek HEAD
localhost:9410
The context-aware which-key hint bar along the bottom of the diff
03 / Comment anywhere

Inline threads on the new side or the old.

Press c to open the comment editor on the cursor line, or v to select a range first. Single-line or multi-line, new-side or old-side, threads work identically across all three diff modes.

localhost:9410 — src/search.ts
The inline comment editor open on a diff line
04 / LLM in the loop

Hand the threads to your coding agent.

A bundled Claude Code skill lets an agent play reviewer (leave inline comments) or reviewee (address open threads, edit source, reply) by reading and writing the .reviews/ JSON directly. No HTTP API, no running server.

# install the skill, then just ask in plain language npx skills add genkio/slop-review # "address the open slop-review threads" # "act as reviewer for this branch"
localhost:9410 — thread
A review thread: a reviewer question and the agent's reply
05 / Blob-keyed reviewed marks

Sign off on a file. Keep it green until it actually changes.

Click a file header to mark it reviewed (and collapse it). The mark is keyed to that file's blob SHA at marking time, so a later push that touches one file invalidates only its mark. Every untouched file stays green.

  • Per-commit marking is gated to "no later changes", so you never sign off on content you weren't looking at
  • p peeks the file at HEAD without leaving the commit view
localhost:9410 — 4/8 reviewed
Files collapsed to green reviewed headers
peek HEAD
The Peek HEAD modal showing the file's current state from a commit view
06 / Cross-file symbol panel

Double-click an identifier, see every occurrence.

Double-click any identifier in the diff to list every occurrence across changed files, with the active row highlighted in place. Open a second symbol and the first parks into a right-edge strip, match list and jump history preserved, so you can pivot between concurrent searches without losing context.

localhost:9410 — symbol: Note
The cross-file symbol panel listing occurrences of an identifier across files
07 / Three diff modes, one page

Full branch, any commit, or your working copy.

Cumulative diff vs base, any single commit, or the local working-copy diff. Shift+← / Shift+→ steps between them; comments work in all three. Cold launch resumes the last view for the branch, or falls back to a sensible per-commit default.

localhost:9410 — local working copy
The local working-copy diff view
08 / One-way GitHub sync

Pull unresolved PR threads down to local.

slop-review --sync mirrors the unresolved review threads from your branch's GitHub PR into local threads, keeping each GitHub author. Re-running mirrors GitHub: new replies flow in, resolved threads are deleted locally, and anything you've touched locally is flagged so your edits stay put — new GitHub replies still append, but your work is never overwritten.

  • Synced threads carry a GitHub badge and link back to the original comment
  • Keeps re-syncing every 5 min while the UI stays open
localhost:9410 — synced thread
A GitHub-synced thread showing the GitHub badge and original authors
09 / Branch overview on demand

An LLM-generated map of the change set.

The Overview modal generates a branch summary on demand using codex exec or claude: what changed, the mental model, before/after behavior, and a small architecture sketch rendered as a diagram.

localhost:9410 — overview
The branch overview modal with numbered what-changed cards
overview — sketch
The overview architecture sketch rendered as a node diagram
Everywhere you review

Reads great on a phone. Reviews great in a terminal.

The diff collapses to a single readable column on small screens, and the whole review loop, threads, replies, the ;; submit chord, works inside Carbonyl.

Mobile web
slop-review diff on a phone
Terminal thread
zsh — carbonyl
A review thread open inside the terminal via Carbonyl
Keyboard-first

The whole loop, on the home row.

The same bindings work in a regular browser and in Carbonyl.

jkMove cursor down / up a line (JK for five)carbonyl ✓
cCComment on the new-side / old-side line
vVStart a visual-line selection
yCopy a path:line reference to the cursor line
rToggle the cursor row's file as reviewed
nNJump to next / previous thread in view
pPeek HEAD for the cursor row (commit view)
eExpand context lines around the hunk
⌘/CtrlSubmit the comment editoruse ;;
Step between commit / full / localuse
Getting started

One command inside any git repo.

The cwd is auto-bootstrapped as the review target, the server picks a free port, and your browser opens. Threads live in .reviews/, gitignore it to keep them local.

Run it

No install, no config. Node ≥ 20 and git on PATH.

cd /path/to/your-feature-branch npx slop-review

Terminal mode

Render the UI straight into your TTY via Carbonyl.

# macOS, via the genkio/tap homebrew tap brew install genkio/tap/carbonyl slop-review --carbonyl

Teach your agent

Install the bundled skill so an LLM can play reviewer or reviewee.

npx skills add genkio/slop-review

Sync a GitHub PR

Mirror unresolved PR threads into local, then open the UI.

slop-review --sync --browser