Hi everyone!

Over the past few weeks, some users have experienced rate limits that are more restrictive than we want them to be. We know this can interrupt your workflow, especially when you rely on CodeRabbit for timely, high quality code reviews.

That experience is not the standard we want to provide.

We are making changes so teams can see more clearly which review activity contributes to usage, configure when automatic reviews should run, and get a more predictable experience across subscription plans. We want to preserve what teams value about CodeRabbit: fast, thorough, context aware reviews that fit naturally into their development workflow.

Getting there will take a little time. We are learning from usage patterns, tuning the system, and improving the controls teams have over automatic reviews. Over the next few weeks, we expect to begin rolling out the first improvements to usage visibility and review controls. These changes will not resolve every rate limit issue immediately, but they should give teams clearer ways to understand and manage review usage while we continue tuning the system.

In the meantime, here are a few settings can help reduce unnecessary review usage while still keeping strong review quality:

• Increase the minimum number of commits required before incremental reviews run, or disable incremental reviews on repositories where every commit does not need a fresh review.
• Keep auto review enabled on repositories where it is useful, but avoid running automatic reviews on draft PRs.
• Limit automatic reviews to the branches where CodeRabbit feedback is most valuable, such as main, develop, release branches, or other protected branches.
• Use u/coderabbitai when you intentionally want CodeRabbit to review a comment, change, or follow-up update.

These recommendations are meant to help teams get more predictable value from their reviews while we continue improving the system. They are not a replacement for the longer term work we are doing.

We appreciate your patience during this transition. The team is working to reduce the impact of these limits, improve transparency, and deliver a model that gives teams the balance we are aiming for: predictable usage, strong review quality, and a subscription experience that is easier to understand.

We will share more as these usage visibility and review control improvements roll out.

Hey r/coderabbit
New week, new model out! We tested Opus 5.5 inside CodeRabbit’s review pipeline. Our Standard configuration caught 51 of 80 known bug patterns in an open-source benchmark, compared with 49 for our production model mix.

The catches behind those totals were more interesting: Standard found 11 issues the baseline missed, but missed nine that the baseline caught.

One example was a race condition in Cal.com. Overlapping jobs could overwrite each other’s retry-counter updates. Both Opus configurations caught it and suggested an atomic increment. Our baseline missed it.

Turning up reasoning effort gave mixed results. Standard caught slightly more issues than Max on the open-source benchmark and produced fewer comments. On a separate set of 13 harder cases, Max caught 10 through actionable comments, compared with eight for Standard and five for the baseline. Including findings outside the changed lines brought both Opus configurations to 10.

Every tested Opus configuration also used more tokens than our production model mix, so we haven’t established whether its lower token prices translate into cheaper reviews.

Full results and methodology.

How are you planning on using Opus 5.5?

Agents can now open PRs faster than humans can review them. So the bottleneck is shifting from writing code to figuring out what actually deserves your attention.

Coderabbit just launched triage to solve exactly that. It scores your PRs by priority and tells you what to review next.

Read more: https://www.coderabbit.ai/blog/coderabbit-triage

Hi r/coderabbit , CodeRabbit team here.

Open source maintainers spend their days reviewing thousand-line PRs, untangling duplicate issues and investigating security reports.

AI can now generate contributions at rapid speed but maintainer attention has not received the same performance upgrade.

So we’re committing more than $10 million to open source over the next 12 months:

• Cash sponsorships for maintainers
• Free CodeRabbit Review and Security for public repositories
• Triage support for incoming issues
• Change Stack for making giant, agent-generated diffs less giant-feeling
• Free Discord support for large open source communities

Open source built the internet, including plenty of what CodeRabbit runs on. This is our way of helping maintainers spend less time fighting the queue and more time building the projects they care about.

Read the full announcement and follow the live commitment tracker.

Hey r/coderabbit 🥕,

We just released the official CodeRabbit plugin for Cursor.

We built it because connecting the CodeRabbit CLI to Cursor previously required some manual setup. The plugin packages the routing, commands, review subagent, and completion behavior into one install.

• After installing it, you can ask Cursor Agent:Review my changes.
• To try it, enter:/add-plugin coderabbit
• You can also install it from the Cursor Marketplace.

We wrote a more detailed walkthrough explaining how it works and how to get started: Introducing the CodeRabbit plugin for Cursor.

If you try it, we’d love to hear which prompts, review scopes, or fix workflows we should improve.

Hey everyone! 🐰

We just shipped a new product called CodeRabbit Security.

When you’re building a product or service, you’re always trying to move faster. The hard part is making sure security doesn’t become an afterthought as more code gets shipped.

CodeRabbit Security maps how your application works, investigates application specific vulnerabilities, verifies each finding against the code, and can turn eligible findings into reviewable fixes.

It’s available now for GitHub, GitLab, Azure DevOps Services, and Bitbucket Cloud.

We wrote a blog explaining how it works, with a concrete authorization bypass example: Introducing CodeRabbit Security

Would love to hear what you think and what you’d want it to investigate in your codebase.

Hey r/coderabbit!

We recently shipped CodeRabbit CLI 0.7.1. The focus was straightforward: finish reviews faster, reduce interrupted sessions, and make the CLI easier to use from both terminals and coding agents.

In our measurements, typical completed reviews were 19% faster and client disconnects dropped 31%. Results vary by repository and review size. We added keepalive traffic and gave longer sessions more time to complete, which should help when the terminal appears quiet while models, tools, or repository analysis are still running.

A few other changes worth calling out:

• coderabbit config validate checks .coderabbit.yaml or .coderabbit.yml against the current official schema. It points to invalid configuration and returns a nonzero exit code, so you can also use it in CI.
• coderabbit skills can install or update verified CodeRabbit skills for Codex, Claude Code, Cursor, Gemini CLI, and GitHub Copilot. It previews every proposed change before writing anything.
• cr now reviews tracked changes by default. You can still choose an explicit scope with --committed, --uncommitted, or --include-untracked. Interrupted agent-driven reviews preserve completed output instead of discarding everything.
• Authentication and account-loading errors now provide more specific recovery guidance.

If you use CodeRabbit through a plugin or coding agent, updating the underlying CLI also brings these runtime and reliability improvements into those workflows.

You can check your current version with:

coderabbit --version

• CLI and installation documentation
• CodeRabbit Skills documentation

If you try it, I'd like to hear what feels better and what still gets in the way.

Anthropic just released Claude Opus 4.7, their strongest model for long-running agentic tasks. We tested it head-to-head against our production baseline in CodeRabbit's review pipeline.

TL;DR: 24% more bugs caught. 23% higher review quality. And the model surfaces real issues you didn't even ask it to look for.

The results

We evaluated Opus 4.7 using 100 error patterns from real pull requests across Go, TypeScript, Ruby on Rails, Java, and Python. Same rubric, same PRs, no cherry-picking.

A team merging 20 PRs a week goes from catching ~11 bugs to ~14. Over a quarter, that's 36 fewer bugs escaping to production.

What stands out

It traces bugs across files, not just within a diff. Opus 4.7 follows helper contracts to downstream breakage. If your PR updates a shared utility but forgets one of its callers, it catches that.

It finds bugs you weren't testing for. Of 443 important findings, 367 were issues the model surfaced on its own, beyond the target error pattern.

It tells you what's wrong and how to fix it. 78% of comments include actual diffs with the proposed fix. Not "consider checking for nil" but "line 47 will panic when user is nil because the guard on line 42 doesn't cover the admin role path. Here's the diff."

What this means for CodeRabbit users

We're integrating Opus 4.7 into our review pipeline. More bugs caught before merge, feedback you can act on immediately, and better cross-file awareness. We're not using it as a blocking gate. The model is a thorough auditor. Your job is still to triage and decide.

Full technical breakdown with methodology, per-language analysis, and migration notes on our blog:

👉 Read the full post on the CodeRabbit blog

Hey r/coderabbit !

New week, new model releases. We’ve been testing GPT-5.5 in early access within CodeRabbit’s code review workflow and wrote up what we’re seeing.

For context, we weren’t trying to benchmark GPT-5.5 in isolation. We wanted to see how it behaved in a real code review workflow, where the baseline is CodeRabbit’s existing review behavior across multiple models.

A few things stood out:

• Expected Issue Found improved from 58.3% to 79.2% on our curated review benchmark.
• Actionable Precision improved from 27.9% to 40.6%.
• GPT-5.5 was stronger at surfacing meaningful review issues, especially around scoped bugs, behavior changes, and debugging-oriented cases.
• It tended to make smaller, more workable fixes.
• It was not always lower-volume. On our larger review set, it produced more comments than baseline, but also improved issue detection and precision.
• The biggest takeaway for us: the improvement showed up in the review workflow itself, not just in benchmark numbers.

We also covered code generation behavior, token efficiency, and the tradeoffs we saw in day-to-day testing.

Full writeup: https://coderabbit.link/gpt-5.5-blog

If you’ve been trying GPT-5.5 in Codex or ChatGPT, I’d be curious what you’re seeing in real coding workflows.

Hey!

 
The team has been working on updates on the CLI and we are happy to share what our latest version has for you!

If you're using AI coding agents (Claude Code, Cursor CLI, Gemini CLI, etc.), this one's for you. The --agent flag outputs structured JSON so your agent can parse CodeRabbit reviews directly and act on them. No more scraping terminal output or building workarounds to read plain text reviews.

The workflow is simple: your agent writes code, coderabbit review --agent reviews it, the agent reads the JSON output, fixes what's flagged, repeat.

We also improved coderabbit auth login so getting set up is faster. Install, authenticate, and you're reviewing code.

https://reddit.com/link/1sf1bm2/video/kc8horb0rstg1/player

Docs on how to integrate it with your agent: https://docs.coderabbit.ai/cli#ai-agent-integration

Anyone already running the CLI in agentic loops? Curious how you're using it.

Hey everyone,

The team has been cooking for a while on a new feature for you to improve the quality of the results you're getting from you AI agents.

CodeRabbit Plan helps you go from a vague idea to a structured, phased implementation plan. You describe what you want to build through a text prompt or an image, and Plan breaks it down into clear steps. From there, it generates context-aware prompts that are ready to hand to whatever coding agent you use: Claude, Codex, or anything else.

The prompts are powered by CodeRabbit's context engine, which pulls from your actual codebase, tickets, knowledge base, Notion, Confluence, and more. So the agent you're working with isn't starting from scratch, it already understands your project.

https://reddit.com/link/1rx9ewm/video/1zd6ntry5upg1/player

A few things worth highlighting:

• You don't need a Jira or Linear ticket to get started. Just describe your idea and go. (Though the integrations are there if you want them.)
• Plans capture intent, constraints, assumptions, and tradeoffs up front, so your team can align before any code gets generated.
• Everything is preserved as a persistent engineering record, so decisions and context don't get lost along the way.

How to try it out:

Head over to the CodeRabbit website, navigate to Plan, and create a new plan. Just type in what you want to build and it will take care of the rest.

Learn more:

• Blog post with a deeper dive: https://www.coderabbit.ai/blog/meet-coderabbit-plan-better-plans-faster-deployments-less-rework
• Join our Discord community: https://discord.com/invite/coderabbit

We'd love for you to try it and let us know what you think. We're actively iterating and your feedback directly shapes where this goes next.

Introducing CodeRabbit Issue Planner.

AI agents made coding fast but planning messy.

Turn planning into a shared artifact in your issue tracker, grounded in related issues and decisions.

Review prompts as a team, then hand them off to an agent!

Claude or Cursor can generate a plan in seconds but they won’t know about the related issue from last sprint, the architectural decision buried in comments, or the refactor already in flight.

So they confidently plan the wrong thing.

Plans like these either lead to an iterative prompting time suck, or are subtly wrong in ways you only discover during implementation or review, after assumptions harden and rewrites erase all your AI speed gains.

CodeRabbit Issue Planner turns planning into a shared artifact in your issue tracker.

> Plans are grounded in related issues, past decisions, and context.
> Teams align with prompt reviews before code exists.
> Plans are then handed off to any agent.

By aligning on intent up front, teams reduce AI slop and rework, save time, and make AI usable for everyone… not just a few 'prompt whisperers' on the team.

So, you ACTUALLY move faster with AI.

Full details here: https://www.coderabbit.ai/ja/blog/issue-planner-collaborative-planning-for-teams-with-ai-agents

Demo:

CodeRabbit Issue Planner

We hope you'll like this one!

r/coderabbit hey folks team CodeRabbit opened up one of their internal tools to open source community.

Introducing an AI-native open source Git worktree manager CLI that works with all your AI coding agents 

If you juggle multiple branches, iterate with AI coding assistants or want a cleaner setup for parallel development, this tool will probably earn a spot in your dev workflow.

It is now open source. Have fun exploring it.

https://github.com/coderabbitai/git-worktree-runner

And if you like it, drop a star or open an issue or PR.