How ThinkReview integrates into Cursor and Claude and finds real bugs before they are live

Cursor and Claude Code can write the bug and the test that misses it. ThinkReview reads the pull request before that branch is live.

Cursor and Claude Code will turn a sentence into files, a test, and a recap that says the feature is done. The test belongs to the same session that wrote the code. It passes when the path the agent remembered still works. The bug that reaches a user is the path the test never named.

ThinkReview integrates into both tools the same way. An MCP server exposes one tool, review_url_code. A skill tells the agent to call that tool on the pull request URL, fix the findings that are real, and review again. ThinkReview fetches the diff on the host. Why that matters when you are the only reviewer is in AI code reviews for vibe coders.

A Cursor run where the tests had already passed

Pull request 96 is a plain example. The coding session had draft tests, and those tests passed, including the remix-note cases. The local page still loaded. The session was signed out, so a live remix never ran in the browser. The recap could have stopped there.

/thinkreview-pr called ThinkReview on the pull request. Two high findings were real, and the fixes are on the branch.

Pull request 96 in Cursor. ThinkReview found two high bugs the draft tests had missed. The agent fixed those, and it left the findings that were already handled.

The first bug was in how a remix got marked saved. generateCampaign has to return remixApplied before the remix counts as saved. The request was also sending regenerate. An older function then rewrote the draft and stripped the note. The fix stops sending regenerate on that request, so the older function leaves the draft alone.

The second bug was a click guard that could drop a field edit. A normal edit hit the guard and never saved. Removing the guard lets those edits save again.

The same review was wrong about one item, and the skill treated it that way. A secondary-language finding said fields were missing. The page already sends the fields for the language you are viewing. A second review, after the fixes, raised more items marked critical or high. They described paths that already throw before a write, the message the product shows when a remix does not run, or a nit about a 40-key loop. Those stayed as notes.

That is the integration doing the job people hope a local “review this diff” prompt will do. The writing agent and its tests had a clean run. ThinkReview, called on the URL, found the two breaks that would have shipped. The skill’s second job was knowing which later findings to leave in place.

What actually gets called

The hosted server is https://mcp.thinkreview.dev/v1. Authentication is browser OAuth, so the config is a URL.

review_url_code takes the pull request or merge request URL. Optional arguments are language, mrId, and forceRegenerate when you want a fresh review after new commits. Reviews use the same credits as the browser extension. An unchanged file list comes back from cache. forceRegenerate: true spends a new credit and writes a new review.

ThinkReview reads the diff with the git credentials saved under Settings → Integrations in the portal. Supported hosts are GitHub and GitHub Enterprise Server, GitLab.com and self-managed GitLab, Azure DevOps Cloud and on-premise, and Bitbucket Cloud and Bitbucket Data Center. Custom rules on the account apply.

Cursor or Claude Code gets that result back as the review: summary, severity, security notes, best practices, and follow-up questions.

Add the MCP server

Cursor. The short path is the Cursor Directory listing. Installing it adds the server and a review skill together. The source is Thinkode/thinkreview-cursor.

Source: ThinkReview on the Cursor Directory. The plugin installs the MCP server. The Skills tab is the review skill that ships with it.

A hand-written config still works. In Cursor → Settings → MCP:

{
  "mcpServers": {
    "thinkreview": {
      "url": "https://mcp.thinkreview.dev/v1"
    }
  }
}

Enable thinkreview, click Authenticate, and finish consent on the ThinkReview portal.

Claude Code. One command adds the same URL:

claude mcp add --transport http thinkreview https://mcp.thinkreview.dev/v1

Claude Code writes the server into its local config. Then run /mcp and authenticate. After consent, review_url_code is available in the session.

Before the first review in either tool, the git host needs a personal access token in the portal. OAuth connects your ThinkReview account to the editor. Read access to private pull requests comes from that integration credential. Full configs, including Claude Desktop and Copilot, are in the MCP integration guide.

Add the skill so the agent uses it

A connected server is a tool the model can skip. The skill is the standing instruction to call it. In Cursor the Directory plugin includes review-pull-request, which runs when you ask for a review of a URL and returns ThinkReview’s write-up. The loop that fixed pull request 96 is /thinkreview-pr: review, fix the real critical and high findings, test, push to the same pull request, review again.

Add it as a skill file. The folder name is the slash command.

---
name: thinkreview-pr
description: Review the current pull request with ThinkReview, fix real critical and high findings, test, push to the same pull request, and review again.
---

# ThinkReview PR loop

1. Resolve the pull request URL. If the branch has none, push this chat's work and open one.
2. Call ThinkReview MCP `review_url_code` with that URL.
3. Fix critical and high findings that are real defects in this change. Leave nits, speculative risks, and findings the code already handles.
4. Run the tests that cover the edit. If the change is something a user can click, exercise that flow.
5. Push the fixes to the same pull request when the tests pass. No force push.
6. Call `review_url_code` again with `forceRegenerate: true`. Repeat until the real high issues are gone, up to three passes.

Reload the editor so the new command shows up. Then /thinkreview-pr is the whole loop in Cursor and in Claude Code. Step 3 is what kept pull request 96 honest. The two high findings became code. The wrong language finding and the later nits stayed in the write-up, and they stayed off the branch.

Before the branch is live

Cursor and Claude Code will keep writing faster. The protection is a review of the URL, from ThinkReview, while the change is still a pull request.

Add the ThinkReview MCP server, add the /thinkreview-pr skill next to it, and run it before you merge. Setup starts at portal.thinkreview.dev/mcp. The same review is available in the browser if you want it on the pull request page itself.

• Chrome
• Firefox
• Edge

ThinkReview reviews pull requests from the browser extension or from MCP inside Cursor and Claude Code.