NewConnect Sentry, PostHog and your database

AI code review on GitHub pull requests

Sinatra reviews pull requests on GitHub and posts what it finds as a review, with inline comments on the changed lines and a sinatra / review check on the commit. It does this in two places: on the pull requests your team opens, once an owner or admin turns reviews on, and on the pull requests Sinatra opens itself, before it marks them ready.

Two kinds of review

Reviews of your team's pull requests are new as of November 21, 2026. Sinatra reviews pull requests opened by members of your workspace, however the code was written: by hand, in Cursor, in Claude Code or anything else. It is the same kind of automatic review as Cursor Bugbot or CodeRabbit. It comments and reports a check, and it never approves, requests changes, or pushes code.

Self-review covers the pull requests Sinatra opens from a task. They open as drafts, and before marking one ready Sinatra reviews its own diff against the ticket. Unlike a review of your team's code, self-review can push a fix to its own branch. It has its own section below.

What a review looks for

Concrete correctness and security defects in the pull request. Every finding has to point at a line the pull request actually changed, explain the defect and its impact, and carry a severity:

  • P0: security, data loss, a crash or an outage.
  • P1: incorrect behavior or a broken contract on a reachable path.
  • P2: a real but non-blocking defect, or a missing test for risky logic.
  • P3: hardening or a nit.

The reviewer is told not to invent findings and not to downgrade one because the fix is easy or the rest of the pull request is good. It compares from the point where your branch left the base branch, so commits that landed on the base branch later aren't counted as your changes. When you push new commits, the next review focuses on what changed since the last reviewed commit.

What a review looks like

One GitHub review per pull request head. Its summary opens with an AI Code Review report card: an overall risk level as a percentage, a one-sentence read on the change, and a risk breakdown with one row per changed file, each linked to that file's diff. The overall level weighs the findings along with how much the change touches, how complex it is, whether it is tested, and whether it reaches security, data, concurrency or external contracts. Below 40% is low, 40 to 69% is medium, and 70% and up is high. The format, taken from the reviewer's own instructions:

## AI Code Review

**Risk Level:** 🟢 LOW (21%)

[One-sentence narrative describing the overall risk posture.]

### Risk Breakdown
| File            | Risk   | Reason             |
|-----------------|--------|--------------------|
| path/to/file.ts | 🟢 LOW | one-line rationale |

Findings tied to a line sit inline on that line, each starting with its severity. Findings that can't be tied to a changed line go in the summary after the report card. A pull request with nothing to report still gets a review that says no actionable findings were found.

If you reply to a finding with a direct question, such as whether your change fixes it or whether the severity is right, the reviewer answers in that thread and says whether the finding stands, is withdrawn, or changes severity.

The sinatra / review check

The check appears as soon as the pull request is waiting for a review, shows in progress while the review runs, and finishes with the result. It fails while open, unresolved P0 or P1 findings remain, and passes when none do. When the pull request closes or new commits replace the head under review, the old check is cancelled. If a review can't run because of the model account, the check says what to do: connect or reconnect the account, add credit, wait for a usage limit to reset, or pick a supported model.

A check on its own doesn't stop anyone merging. To hold merges until a review finishes, make sinatra / review a required check in your repository's branch rules.

Turning on reviews for your team

1
Connect GitHub

Sign in at app.sinatra.dev and install the GitHub App on your repositories. Reviews need the app's Checks: write and Pull requests: write permissions. An installation that hasn't approved them yet sees a prompt in Settings, and reviews wait until the permissions are approved.

2
Turn on Pull request reviews

An owner or admin opens the workspace's Settings and sets Pull request reviews to On. Reviews are off until someone does.

3
Override per repository if you need to

Each repository follows the workspace setting unless you set it to on or off for that repository alone.

4
Have authors link GitHub and a model

Every author whose pull requests should be reviewed needs to be a member of the workspace with their GitHub account linked, and needs their own model access connected, because the review runs on it.

When a pull request isn't reviewed

A review runs only when the pull request's author is a workspace member with their GitHub account linked. Pull requests from anyone else aren't reviewed. It runs on that author's own model credentials, so an author with none gets no review. Drafts aren't reviewed until they are marked ready.

Each review takes a running slot, the same as a task, and waits in the same queue when every slot is busy. People's tasks are served before automated work. On Free that is 1 agent at a time, plus 1 waiting, so a review and a task wait for each other. When every slot and the queue are full, the check says Not reviewed instead of staying silent. That neutral check doesn't mean the pull request was reviewed: re-run the check or comment @sinatra review to ask again.

Self-review of the pull requests Sinatra opens

When Sinatra works a ticket from Linear, GitHub, Slack, Telegram, the CLI or MCP, the pull request it opens starts as a draft. Before marking it ready, Sinatra reviews its own diff against the ticket and posts the same AI Code Review report card, so a human reviewer sees a risk level before the pull request is ready.

Self-review can fix what it finds. When it pushes a fix, it runs your repository's own pre-merge verification again on the new commit, as named in your agent instructions and contributing docs. If that fails because of the fix, it reverts the fix. If it fails for another reason or can't run in the sandbox, the review says which command and what blocked it.

The result goes on the same sinatra / review check: open P0 or P1 findings fail it, P2 and P3 findings leave it neutral, and no findings pass it. Self-review is best effort. If it errors, the error is reported and the pull request can still be marked ready, so a ready pull request doesn't prove the review or the tests passed. More in How it works.

It can be wrong

Sinatra is an AI agent. A review can miss a real defect or flag one that isn't there, and a passing check means the reviewer found no open P0 or P1 findings, not that the code is correct. Keep your own tests, required checks and human review as the merge gate. Sinatra doesn't merge or deploy; you do.

What it costs

A review uses a running slot from your plan and the author's model account. Free is 1 agent at a time, plus 1 waiting, with no daily limit and no card. Pro is $20 a month for the whole workspace: 3 agents at a time, plus 10 waiting, any number of people. Sinatra never bills for model usage. That's between you and your provider. The permissions the GitHub App asks for are listed in the GitHub App docs.

Common questions

Does Sinatra approve pull requests or block merges?

It never approves and never requests changes. Each review is a comment review, and the outcome goes on the sinatra / review check: it fails while open, unresolved P0 or P1 findings remain and passes when a finished review leaves none. A review that couldn't run says why on the check. The check blocks a merge only if you make it a required check in your repository's branch rules.

Can it change the code in my pull request?

No. A review of your team's pull request runs with a GitHub credential that can read the repository and write to pull requests, and nothing else, so it can't push. It posts the review and replies in threads. If you want Sinatra to write the fix, hand it a task.

Whose model account pays for a review?

The pull request author's. A review runs on the author's own model credentials, so an author who hasn't connected any gets no review. Bring your own Claude, ChatGPT or Cursor subscription, or an API key. Sinatra never bills for model usage. That's between you and your provider.

Why didn't my pull request get a review?

The usual reasons: reviews are off for the workspace or for that repository, the pull request is still a draft, the author isn't a workspace member with a linked GitHub account, or the author has no usable model credentials. If every running slot and the queue were full, the check says Not reviewed; re-run the check or comment @sinatra review to ask again.

Can I argue with a finding?

Yes. Reply in the finding's thread. When you ask the reviewer a direct question about a finding, its severity, or whether your change resolves it, it replies in that thread and says whether the finding stands, is withdrawn, or changes severity, and why. A thanks or a resolved thread gets no reply.

How is this different from Sinatra's self-review?

Self-review is part of a task: it checks a pull request Sinatra wrote, against the ticket, before marking the draft ready, and it can push a fix. Pull request reviews are for the pull requests your team opens, however the code was written, and they only comment.

Sinatra also writes the code. Hand it work from a Linear assignment, the Sinatra label on a GitHub issue, a Slack mention, an MCP client or the CLI and API. Questions about reviews go to contact@sinatra.dev, or see Support.

Sign in to turn on reviewsPro is $20 a month for the whole workspace