Container Orchestration

Introduction

Imagine reviewing a pull request where an AI not only catches more real bugs than built-in tools but also explains each issue, walks you through uncertain findings, and even applies fixes without breaking existing code. That’s exactly what adamsreview delivers. This Claude Code plugin transforms your standard PR review into a multi-agent, multi-stage process with persistent state, ensemble validation, and interactive walkthroughs. Whether you’re a solo developer or part of a large team, adamsreview helps you spot issues that /review, /ultrareview, CodeRabbit, Greptile, or Codex’s built-in reviewer often miss—while producing fewer false positives. In this guide, you’ll learn how to install, configure, and use all six slash commands to get the most out of your AI-powered code reviews.

What You Need

• Claude Code (Max plan recommended) – adamsreview runs against your regular subscription, unlike /ultrareview which charges extra.
• GitHub repository with a pull request to review.
• Node.js (for plugin installation via marketplace commands).
• Codex CLI (optional but recommended for ensemble review).

Step-by-Step Guide

Step 1: Install the Plugin

Open your Claude Code terminal and run the following two commands to add the plugin from the marketplace:

1. /plugin marketplace add adamjgmiller/adamsreview
2. /plugin install adamsreview@adamsreview

That’s it – the plugin is now available. It adds six slash commands: review, codex-review, add, promote, walkthrough, and fix. All state is stored as JSON artifacts on disk, so you can clear context between stages without losing progress. The plugin also ships with built-in scripts to keep the state data updated automatically.

Step 2: Run a Multi-Agent Review

Start with the core command /adamsreview review. This launches parallel sub-agents that each examine your PR from a different perspective (e.g., security, performance, readability). The agents work simultaneously, then merge findings into a persistent JSON state file. Because the plugin uses multiple agents in parallel, it catches dramatically more real bugs than a single-agent review. After the review completes, you’ll see a structured report with severity levels and actionable suggestions.

Step 3: Use Codex Ensemble Review

For even deeper validation, run /adamsreview codex-review. This triggers an ensemble review using Codex CLI alongside the Claude agents. The Codex agent independently analyzes the same PR and produces its own set of findings. The plugin then cross-references both outputs, highlighting agreements (high confidence) and discrepancies (needs manual review). This ensemble approach reduces false positives and provides a second opinion on tricky changes. If you don’t have Codex CLI installed, the command will gracefully skip the ensemble step.

Step 4: Add and Promote Findings

After the initial review, you may want to include specific issues that the agents didn’t flag or upgrade a minor finding to a critical one. Use these commands:

• /adamsreview add – Manually add a new issue to the state file. You’ll be prompted for the file path, line numbers, and description.
• /adamsreview promote – Change the severity of an existing finding (e.g., from “warning” to “error”). Useful if you disagree with the agent’s assessment.

Both commands update the persistent JSON state on disk, so your changes survive context clears and are visible to subsequent commands.

Step 5: Walk Through Uncertain Issues

The most powerful feature is the walkthrough command: /adamsreview walkthrough. This uses Claude’s AskUserQuestion capability to present uncertain findings one by one. For each item that needs human judgment, the AI explains the context and asks you a specific question (e.g., “Should this variable be renamed to something more descriptive?”). You answer yes/no or provide additional instruction. This interactive process ensures that only well-reviewed changes make it to the final fix stage. It’s especially valuable for ambiguous scenarios like naming conventions or architectural tradeoffs.

Step 6: Apply and Validate Fixes

Once you’ve walked through all uncertain issues, run /adamsreview fix. This command:

1. Dispatches per-fix-group agents – Each group of related fixes gets its own AI agent to implement changes.
2. Re-reviews with Opus – After applying the fixes, the plugin uses Claude Opus (the most powerful model) to re-evaluate the entire diff. If Opus detects a regression (e.g., a fixed bug that broke another part), the plugin reverts that specific change before committing.
3. Commits survivors – Only fixes that pass the re-review are committed. The commit message includes references to the original findings.

This multi-stage pipeline minimizes the risk of introducing new bugs while maximizing the number of genuine issues resolved.

Tips & Best Practices

• Use the Max plan – While the plugin works with lower tiers, the Max plan provides the context window and compute needed for parallel agents and ensemble reviews without hitting rate limits.
• Keep state files in your `.gitignore` – The JSON artifacts are ephemeral; don’t commit them to the repo. The update scripts will regenerate them as needed.
• Combine with manual review – AdamsReview is a powerful assistant, but final decisions should always be made by a human. Use the walkthrough step to inject your expertise.
• Experiment with parallel agents – The default agent count is good for most projects, but you can adjust it (see plugin config) for larger or more complex PRs.
• Report false positives upstream – If you notice recurring false positives, share them with the developer (Adam Miller) on GitHub so the plugin can improve.

By following these steps, you’ll transform Claude Code into a robust, multi-faceted code review tool that catches real bugs, reduces noise, and speeds up your development workflow. Try it on your next PR and see the difference for yourself.