Start a trial

Reviews that matter, in seconds.

Unblock your GitHub PRs with Rapid Review. Don’t waste time and tokens on slow and noisy reviews.

Start a trial See what a review posts

Any programming language · Trial: 50 credits or 14 days, whichever ends first

acme/checkoutRetry failed payments with backoff #482
agent pushed e41b7c214:02
In progress
rapid-reviewReviewing
Successful
rapid-review1 finding postedDetails
src/payments/retry.ts+6 −2
@@ -40,3 +40,7 @@ export async function retryCharge(order) {
40Removed: const res = await gateway.charge(order);
41Removed: if (res.ok) return res;
40Added: const delays = [250, 500, 1000];
41Added: for (let attempt = 0; attempt < 3; attempt++) {
42Added: const res = await gateway.charge(order, { key: uuid() });
Rapid ReviewBotcommented

MajorRetries can charge a customer twice.

retryCharge() makes a new idempotency key on every attempt. When the gateway takes a charge but answers with an error, a 504 from its proxy say, the next attempt has a new key and is charged as a second payment. Create the key once, before the loop.

Suggested change
Removed:   for (let attempt = 0; attempt < 3; attempt++) {Removed:     const res = await gateway.charge(order, { key: uuid() });Added:   const key = uuid();Added:   for (let attempt = 0; attempt < 3; attempt++) {Added:     const res = await gateway.charge(order, { key });
Rapid ReviewBotrepliedResolved

Looks fixed in 9a03f51.

43Added: if (res.ok) return res;
44Added: await sleep(delays[attempt]);
45Added: }
4246 throw new ChargeFailed(order);
agent pushed 9a03f5114:05
Successful
rapid-reviewNo new findingsDetails
Example, not to time. Times in UTC.

Rapid Review by the numbers. Speed, volume, and precision.

How these numbers are counted
Time to review, median
32seconds Half the reviews took less
A review’s change, median
900changed lines 11 files
Findings per pull request, average
3.8 2,746 in all, on 727 pull requests

Over 3,155 reviews in standard mode.

Fast, without being shallow. Where a review’s speed comes from.

Why Rapid Review is fast

In standard mode, most reviews of a pull request are complete in under a minute: every part of the change reviewed, the findings on the pull request as inline comments, and the summary comment and the rapid-review check up to date. Rapid Review was built for speed from the start, without giving up depth: fixed rules where rules are enough, fast models for quick judgements, and frontier models for reviewing the code.

Every part of the changeStandard mode reviews every part of the change, with context from the rest of the repository and the repository’s learnings.
Frontier models on the codeAnthropic’s Claude reviews the code.
Fast models for narrow callsFast models, such as TypeSafe AI’s Jev, make quick, narrow judgements along the way.
Fixed rules where they’re enoughDeterministic code analysis does the work fixed rules do well, with no AI model involved.

From the push to the fix. What Rapid Review posts on a pull request, and what it does with your replies.

On the line it’s about

Each finding is an inline comment with its severity, an explanation and a fix in words. A small, exact fix comes as a suggestion you can commit.

src/export/pages.ts+4 −0
@@ -8,0 +9,4 @@ export const PAGE_SIZE = 500;
9Added: export function pageCount(total, pageSize = PAGE_SIZE) {
10Added: if (total === 0) return 0;
11Added: return Math.floor(total / pageSize);
Rapid ReviewBotcommented

MajorThe export leaves out the last page.

Math.floor rounds the page count down, so the rows after the last full page aren’t exported when the total isn’t a multiple of the page size. Round up instead.

Suggested change
Removed:   return Math.floor(total / pageSize);Added:   return Math.ceil(total / pageSize);
12Added: }

The check

Each reviewed push gets a check named rapid-review. Its title gives the result; its summary, the rest.

Successful
rapid-reviewNo new findingsDetails
2 of 3 earlier findings addressed, 1 open, no new findings. Mode: standard · 9 units reviewed, 3 unchanged Claims: 3 matched · 1 not found Not checked for claims: 1 lockfile Fixed since the last review: 2 Learnings shown: 1

Checks what got fixed

On the next push, every earlier finding is checked against the whole push. A fixed one gets a reply, and its thread is resolved.

Rapid ReviewBotreplied14:05Resolved

Looks fixed in 9a03f51.

Successful
rapid-reviewNo new findingsDetails

Learns from your replies

Reply to a finding with the reason it isn’t a problem, and Rapid Review can record it as a learning for later reviews of the repository.

danareplied10:41

Intended: the importer adds the header itself.

Rapid ReviewBotreplied10:41

Learning recorded for later reviews of this repository: the importer adds the CSV header, so an export may leave it out.

One summary, kept current

One summary comment says how many findings are new and how many are still open. It’s updated on each push.

Rapid ReviewBotcommented14:05

No new findings. No earlier finding is still open.

Adds retries with backoff to failed payments, and records each attempt.

Where the change does what the description says
Retries with backoff: retry.ts, lines 40 to 45.
What each part of the change does
retry.ts wraps the charge in three attempts with growing delays.

Examples of what Rapid Review posts on a pull request. Times in UTC.

For coding agents

Built for the way agents push. Push first, describe later, push again.

Agents often push first and write the description after. Rapid Review can wait for it, reads what the pull request claims, and checks each later push against its earlier findings.

How reviews run
acme/checkoutrapid-review
d4f19a613:582 findings posted
6b2e0d814:05No new findings
c27d0e414:091 finding posted
5b8e1aa14:12No new findings
Recent pushesSuccessfulSkippedSuccessfulSuccessfulSuccessfulSuccessfulSuccessful
Example, not to time. Times in UTC.

Your code and data. What is sent, to whom, and who sees the reviews.

What Rapid Review sends and stores
Not used for trainingReview requests go only to model providers that do not train on the data.
Secrets stay outFiles that look like secrets are never sent to a model.
Seen as on GitHubOnly people who can see a repository on GitHub see its reviews.
You choose what is readFiles your configuration excludes aren’t read for the review.

Choose how to start. Open source, or a team.

Open source

A public repository under a license the Open Source Initiative approves can get free reviews: 100 credits a month and at most 10 in any hour (fair use policy).

An admin of the repository applies in the Rapid Review app, and Rapid Review approves each application.

About free open-source reviews

Teams

Rapid Review Developer is $30 a month with 40 credits. Rapid Review Pro is $49 a month with 70 credits. Rapid Review Max is $119 a month with 200 credits. Prepaid credits cost $1 each, bought in advance. A review uses 1 credit in standard mode and 3 credits in advanced mode.

Trial: 50 credits or 14 days, whichever ends first, plus 100 credits with an invite code. Payments run through Stripe.

Start a trial

Questions

Which programming languages does Rapid Review review?

Any. Rapid Review isn’t built for a fixed list of languages.

Can Rapid Review approve or block a pull request?

It never approves a pull request or requests changes. The rapid-review check blocks merging only if your branch protection requires it.

Are draft pull requests reviewed?

No. A draft is reviewed once it is marked ready for review. Pull requests from forks aren’t reviewed.

How do I make reviews quieter?

Pick a higher confidence tier or leave paths out in .rapid-review.yml, write review instructions in .rapid-review/instructions.md, and reply to wrong findings with the reason.

Where do I see all reviews and findings?

In the Rapid Review app. You sign in with GitHub and see the repositories you can see there.

Get started with Rapid Review.

Rapid Review is a GitHub App. Install it on a personal account or an organization, and choose its repositories.

Start a trial Read the docs

Trial: 50 credits or 14 days, whichever ends first.

How these numbers are counted

Time to review
From when a review starts to when its check is complete and its inline comments are posted: the median, which half the reviews took less than. The wait before a review starts, in the queue or for the pull request’s description, isn’t counted, nor the time GitHub takes to deliver the push and to show the results.
A review’s change
The changed lines, added and removed, and the files of the pull request that a review covers, each at the median. The files a review leaves out, such as lockfiles and files that look like secrets, aren’t counted. On a later push, the parts reviewed before and unchanged since are carried over rather than reviewed again, and count here.
Findings per pull request
Every finding the reviews showed, as an inline comment, in the review or in the check, over the pull requests they reviewed. A finding repeated on later pushes of a pull request counts once.
Reviews
Every review in standard mode that finished, of every account, since Rapid Review began recording them. The numbers are counted from Rapid Review’s review data, and are at most an hour old.