slop-review

A native diff review window for terminal coding agents, powered by Glimpse and Monaco. Ships for Claude Code, Codex CLI, and pi — review the slop before you ship it.

• In Claude Code it adds a /slop-review slash command.
• In Codex CLI it ships as a slop-review skill (auto-invoked when you ask for a review, or explicitly via @slop-review).
• In pi it registers a /slop-review slash command (the upstream this is forked from — see Credit below).

All three:

1. Open a native review window
2. Default to a PR-style review of all changes since your branch diverged from the base branch (auto-detected: origin/HEAD → origin/main → main → origin/master → master), and also support last-commit and uncommitted modes — see Scopes
3. Show a collapsible sidebar with fuzzy file search and git status markers
4. Lazy-load file contents on demand as you switch files and scopes
5. Let you draft comments on the original side, modified side, or whole file
6. Write the composed feedback to a temp file when you submit; the agent reads it back, so the review shows up in the chat as a regular tool call and gets addressed item-by-item

Install

Three hosts, three install paths. All three end with the same review window.

pi

# Recommended: from npm (also lists on https://pi.dev/packages)
pi install npm:pi-slop-review

# Or from GitHub (handy for unreleased commits)
pi install git:github.com/dbachelder/slop-review

# Or pin to a tag
pi install git:github.com/dbachelder/[email protected]

# Or try without installing (single-run)
pi -e npm:pi-slop-review

Then inside pi:

/slop-review                       # default: PR-style review
/slop-review last-commit
/slop-review --base origin/develop

When you submit feedback, the composed prompt drops into pi's input editor
(idiomatic for pi — same UX as the upstream pi-diff-review). Press
Escape while the window is open to cancel.

Note on the npm name. The npm package is pi-slop-review (matches
pi.dev's gallery pi-<name> convention). The slash command, the bin name,
and the plugin name everywhere else are still slop-review.

Claude Code

# inside Claude Code
/plugin marketplace add dbachelder/slop-review
/plugin install slop-review@slop-review

This registers the /slop-review slash command.

Codex CLI

Codex separates marketplace registration (CLI) from plugin enablement (TUI).
Both steps are required:

# 1. Register the marketplace
codex plugin marketplace add dbachelder/slop-review

# 2. Inside `codex`, type:
/plugins

In the plugin browser, switch to the Slop Review (slop-review) marketplace
tab, select the slop-review plugin, and press Install plugin. This enables
the slop-review skill, which the model auto-loads when you ask it to review
your changes (or which you can invoke explicitly with @slop-review).

Why a skill instead of a slash command in Codex? Codex's plugin system
doesn't expose user-defined slash commands; it uses skills (markdown the
model loads when descriptions match the user's intent) and @-invocation.

If you prefer to skip the TUI, enable the plugin by editing
~/.codex/config.toml:

[plugins."slop-review@slop-review"]
enabled = true

Then restart Codex.

How updates flow

For Claude Code and Codex, the GitHub marketplace clone runs a one-time
npm install inside the plugin checkout on first invocation — that's what
installs glimpseui and builds
its per-platform native helper. Codex sets CLAUDE_PLUGIN_ROOT for plugin
shell calls so the same dispatcher works in both agents with no
special-casing. A stamp file under plugin/node_modules/ makes the
dispatcher skip npm install unless plugin/package.json actually
changed.

Standalone CLI / development install

git clone https://github.com/dbachelder/slop-review.git
cd slop-review/plugin
npm install
npm install -g .                # puts `slop-review` on PATH as a standalone binary
npm run install-command         # copies commands/slop-review.md → ~/.claude/commands/

All the plugin contents live under slop-review/plugin/. The top-level
slop-review/ directory holds only the two marketplace manifests, the
root package.json (which exists solely to point pi's git: install at
the extension under ./plugin/), and README / LICENSE / NOTICE.

Credit

This is a fork of badlogic/pi-diff-review by Mario Zechner, which provides the same UI for pi. All of the heavy lifting — the Glimpse window orchestration, the Monaco-based review UI, the comment-and-prompt pipeline, and the in-terminal Escape-to-cancel waiting overlay (in our pi adapter) — was designed and implemented there. This repo:

• Adds a standalone Node CLI (plugin/bin/slop-review.js) so the same UI can be driven from any host that can shell out.
• Adds Claude Code (slash command) and Codex CLI (skill) adapters that use a temp-file + Read round-trip so the review stays visible in the chat UI.
• Adds a pi extension under plugin/extensions/pi/ that registers /slop-review in pi (parallel to the upstream's /diff-review) and uses upstream's idiomatic setEditorText flow — same UX as the upstream.
• Adds PR-style review (everything since merge-base with the auto-detected base branch) as the default scope, with explicit last-commit, uncommitted, and all modes also available.
• Keeps plugin/web/index.html and plugin/web/app.js from the upstream essentially unchanged.

If you only use pi and just want the upstream behavior, install badlogic/pi-diff-review instead. Please ⭐ the upstream regardless.

Requirements

• macOS, Linux, or Windows

• Node.js 20+

• Claude Code, Codex CLI, or pi

• Internet access at runtime for the Tailwind and Monaco CDNs used by the review window

• Native build toolchain — Glimpse compiles a per-platform native helper on first install:

  • macOS: Xcode Command Line Tools (xcode-select --install)
  • Linux: Rust (https://rustup.rs) + GTK4/WebKit2GTK dev packages
    • Fedora: dnf install gtk4-devel webkitgtk6.0-devel gtk4-layer-shell-devel
    • Ubuntu: apt install libgtk-4-dev libwebkitgtk-6.0-dev libgtk4-layer-shell-dev
    • Arch: pacman -S gtk4 webkitgtk-6.0 gtk4-layer-shell
  • Windows: .NET 8 SDK

  Claude Code and some other agents run npm install --ignore-scripts when materializing plugins, which suppresses Glimpse's normal postinstall build. plugin/bin/plugin-run.sh detects this and re-builds the helper explicitly on first invocation, so you'll see a one-time delay (a few seconds for Swift, longer for Rust) before the review window opens.

Windows notes

Glimpse supports Windows, but the native host build during install requires:

• .NET 8 SDK
• Microsoft Edge WebView2 Runtime

Usage

From Claude Code

/slop-review                       # default: all changes since base branch merge-base
/slop-review last-commit           # only HEAD vs HEAD^
/slop-review uncommitted           # only working-tree changes vs HEAD
/slop-review --base origin/develop # override the base branch

The slash command declares an argument-hint, so Claude Code's input autocompletes the available forms.

From pi

/slop-review                       # default: all changes since base branch merge-base
/slop-review last-commit
/slop-review uncommitted
/slop-review --base origin/develop

The pi adapter also registers an autocomplete for the scope argument, so
tab-complete works in pi's input.

When you submit, the composed feedback is dropped into pi's input editor for
you to review and send. While the window is open, press Escape from the
pi terminal to cancel.

From Codex CLI

Just ask for a review in natural language and the slop-review skill auto-loads:

> review my changes
> review the slop on this branch against main
> open a PR-style review

Or invoke it explicitly:

> @slop-review
> @slop-review last-commit
> @slop-review --base origin/develop

What happens

A native window opens. Browse files, leave inline or whole-file comments, then click Submit feedback. The CLI writes your feedback to $TMPDIR/slop-review-<timestamp>.md and prints the path. The agent then reads the file (visible in the UI as a Read / file-read tool call) and addresses each item. Click Cancel or close the window to abort.

Standalone CLI

The binary is a normal Node CLI; nothing about it is agent-specific. You can invoke it directly to drive your own tool integrations:

slop-review [base|last-commit|uncommitted|all] [--base <ref>] [--help]

Contract:

Status messages ("Opened review window…", base-ref resolution, etc.) go to stderr, so stdout stays clean for piping. Example:

out=$(slop-review last-commit)
case "$out" in
  FEEDBACK_FILE:*) cat "${out#FEEDBACK_FILE: }" ;;
  REVIEW_CANCELLED) echo "cancelled" ;;
esac

Scopes

In base mode, the "git diff" tab in the window is relabelled vs <base-ref> so you can tell which ref you're comparing against. If no base branch is found, the CLI falls back to uncommitted and logs a warning.

How it works

  Agent                     bash plugin-run.sh                slop-review
  /slop-review        ───────────────────────────────────►    (Node CLI)
  @slop-review                                                     │
                                                                   │ glimpseui
                                                                   ▼
                          "FEEDBACK_FILE: <path>"             Native window
                       ◄──────────────────────────            (Monaco diff)
  Read tool: <path>
        │
        ▼
  feedback rendered in chat, agent addresses each item

The two-step (Bash → Read) flow is what makes the review visible in the
chat UI: the bash output alone gets folded into the prompt as context, but
the subsequent Read of the feedback file shows up as a regular tool call
with the full file contents.

• plugin/bin/slop-review.js — CLI entry. Parses arguments, resolves the base ref + merge-base when in base mode, opens the Glimpse window, handles file-content requests. On submit, writes the composed prompt to $TMPDIR/slop-review-<ts>.md and prints FEEDBACK_FILE: <path> to stdout. On cancel, prints REVIEW_CANCELLED.
• plugin/bin/plugin-run.sh — Plugin dispatcher. Resolves the plugin root from $CLAUDE_PLUGIN_ROOT (set by both Claude Code and Codex), npm installs on first run, then exec's the CLI.
• plugin/src/git.js — Git scope/diff loader (ported from src/git.ts).
• plugin/src/prompt.js — Feedback prompt composer (ported verbatim from src/prompt.ts).
• plugin/src/ui.js — Inlines web/index.html + web/app.js for the Glimpse window.
• plugin/web/ — Static UI assets (Monaco, Tailwind via CDN, app logic). Copied from upstream.
• plugin/commands/slop-review.md — Claude Code slash command. Forwards $ARGUMENTS to the dispatcher, then instructs Claude to Read the feedback file and address each item.
• plugin/skills/slop-review/SKILL.md — Codex skill. Same instructions, formatted as a skill that the model auto-loads when the user asks for a review.

Layout

slop-review/
├── .claude-plugin/
│   └── marketplace.json          # Claude Code marketplace (string source: "./plugin")
├── .agents/plugins/
│   └── marketplace.json          # Codex CLI marketplace (object source, path: "./plugin")
├── .github/workflows/
│   └── publish-npm.yml           # publishes plugin/ to npm on `v*` tag push
├── package.json                  # ROOT manifest — read only by `pi install git:`
│                                  # so pi finds `pi.extensions: ./plugin/extensions/pi/index.ts`
├── docs/
│   └── screenshot.png            # README image (also used by pi.image gallery preview)
├── scripts/
│   └── bump-version.mjs          # bumps all 6 manifests + lockfiles + README;
│                                  # commits + tags. Run `scripts/bump-version.mjs --help`.
├── plugin/                       # Actual plugin contents — both marketplaces point here
│                                  # AND this is what gets published to npm as `pi-slop-review`
│   ├── .claude-plugin/
│   │   └── plugin.json           # Claude Code plugin manifest
│   ├── .codex-plugin/
│   │   └── plugin.json           # Codex CLI plugin manifest
│   ├── bin/
│   │   ├── slop-review.js        # CLI entry point (Claude + Codex)
│   │   └── plugin-run.sh         # Plugin dispatcher (Claude + Codex)
│   ├── src/                      # SHARED across all three host adapters
│   │   ├── args.js               # arg parser (CLI + pi)
│   │   ├── git.js                # createGitOps({ exec }) — host injects exec
│   │   ├── prompt.js             # composes the feedback prompt
│   │   └── ui.js                 # inlines web/ into a single HTML doc
│   ├── web/                      # Monaco UI bundle (mostly unchanged from upstream)
│   │   ├── index.html
│   │   └── app.js
│   ├── commands/
│   │   └── slop-review.md        # Claude Code slash command
│   ├── skills/
│   │   └── slop-review/
│   │       └── SKILL.md          # Codex skill (auto-loaded; @-invokable)
│   ├── extensions/
│   │   └── pi/
│   │       ├── index.ts          # pi extension entry (registers /slop-review)
│   │       └── types.ts          # wire-format types for the Glimpse ↔ host channel
│   ├── scripts/
│   │   └── install-command.js
│   └── package.json              # name: pi-slop-review; bin: slop-review;
│                                  # pi.extensions: extensions/pi/index.ts
├── LICENSE
├── NOTICE
└── README.md

Two package.json files is the floor: Claude Code and Codex only see the
contents of ./plugin/ after install (their marketplace path points
there), so the npm-publishable plugin manifest must live inside ./plugin/.
pi's git: install reads package.json at the cloned repo root, so a thin
root manifest is needed there too. The two files describe the same plugin
for different consumers; only plugin/package.json is published to npm.

Codex's marketplace path validator rejects ./ outright
(local plugin source path must not be empty), which is why the actual
plugin lives in ./plugin/ instead of at the repo root.

Differences from the upstream pi extension

License

MIT. See LICENSE and NOTICE.

The Monaco Editor and Tailwind assets are loaded from public CDNs; their respective licenses apply.