I've been building Revue since March, and dogfooding it on itself the whole way.
Around week three, I noticed something concerning. I could generate code faster than I could review it. I'd write a feature chunk, scan it quickly, feel confident, and merge. The confidence was real enough. Whether it should have been is another matter, and I wasn't checking hard enough to find out.
The gap between speed and scrutiny
Two findings shifted my thinking:
- About half of AI-generated code carries a security vulnerability, according to Georgetown CSET (Nov 2024).
- Developers using AI write less secure code and trust it more, per a Stanford study published at ACM CCS 2023.
The problem isn't hard to see. AI made code cheaper to write, but it created a new bottleneck: code review. At the same time, it made engineers more confident in their own work, right when they should be more skeptical. Speed increased. Scrutiny did not.
A single AI reviewer bolted onto your PR doesn't solve this on its own: one model, one pass, one opinion, and no one checking the reviewer's work. What helps is an independent review that runs on every change, with a verification step that checks the findings against the code before you see them.
How Revue works
Revue is a code review workflow you control on any model. It runs in two places: locally before you commit, and in CI on every pull request. GitHub Actions, GitLab CI, Bitbucket Pipelines, same review engine everywhere.
Locally, that's the /revue Claude Code skill. Run it against your staged diff inside your existing Claude Code session, before the code ever leaves your machine as a commit.
In CI, Revue runs as a pipeline step and reviews every pull request the same way.
Same six agents, same findings, wherever you run it:
- Security catches injection vectors, auth bypasses, and supply-chain risks
- Performance flags O(nĀ²) loops, memory leaks, and inefficient queries
- Architecture checks for coupling violations and missing error handling
- Code Quality reviews naming, duplication, and testability
- Verification checks each finding against the code and drops the hallucinated or false-positive ones, so what you see are verified findings
- Synthesis reconciles the other five and catches contradictions, posting one comment instead of six arguing voices
Each agent has one job. A security agent looking for auth bypasses needs different context than a performance agent checking query plans. Combining them into one prompt makes both worse. Running them in parallel keeps the review time close to a single agent, not six times as long.
The workflow, not just the comment
Review is useful only if it changes behaviour. Most tools post comments and vanish. Revue does more:
It replies. Respond to a Revue comment and it answers back. Threads get resolved instead of sitting unread.
The security agent flags a missing HTTP timeout. The developer replies that it's handled. Revue acknowledges and closes the thread.
It remembers. Every run gets logged. You have a review history, not feedback that disappears at merge.
It learns. Mark a finding as a false positive and Revue records that pattern into your repo's review config via a small pull request. Merge once, and the team stops seeing that false positive.
Bring your own model. OpenAI, Anthropic, Azure, or any OpenRouter model. Only diffs leave your machine, never the full codebase.
Model-independent review
The review agent improves every time a vendor ships a better model. That part is easy to copy. What isn't easy to copy is the infrastructure: parallel agents, synthesis that catches contradictions, verification that filters hallucinations, the reply loop, the false-positive memory.
Revue's architecture is model-agnostic by design. When a better model ships, it becomes the backend. The workflow stays.
The economics work. I ran the same review workload on two models: Sonnet 4.5 for 13 days cost $78.83. DeepSeek-V4-Pro for 22 days of comparable, often heavier work cost $27 total, and the heaviest single day came to $4.30 on DeepSeek against roughly $15 on Sonnet for similar load. Locally, /revue runs on your existing Claude Code session with no separate charge.
The receipt: 13 days of review workload on Sonnet 4.5 through the API.
DeepSeek trades some precision for cost. For CI review running on every pull request, it's sufficient. You choose the model. Revue is the workflow around whichever you pick.
Try it
Revue is live. Free tier: 10 reviews a month, all six agents, no credit card.
Sign up at revue.sh for a key, then install:
curl -fsSL https://raw.githubusercontent.com/Revue-sh/revue/main/scripts/install.sh | bash
I've been running this on itself since March. If you try it, I'd like to hear how it holds up in your workflow, good or bad: support@revue.sh.
Top comments (0)