AI code review · developerz.ai

developerz.ai includes a native AI code reviewer, the same loop that triages issues also watches PRs. It runs on your BYOK model, on your own box, with no per-review token markup. If you already have CodeRabbit, migrating is a one-liner.

CodeRabbit compatibility

The reviewer reads your existing .coderabbit.yaml and honours the fields below. You do not need to change anything. To migrate off CodeRabbit:

Uninstall the CodeRabbit GitHub App.
Keep your .coderabbit.yaml as-is (or delete it and switch to review: below).

That's it. The developer experience is identical; the inference bill goes to your key.

`.coderabbit.yaml` field support

Every key below is recognized. Honored keys are translated and applied; deferred keys are recognized but not yet acted on (the reviewer posts a warning comment so the gap stays visible); ignored keys are cosmetic or platform-specific and are silently no-op'd. Any key not listed is unknown and surfaces an unknown key warning.

Honored: translated and applied

CodeRabbit key	Mapped behavior
`language`	Review + summary language (BCP-47 tag).
`tone_instructions`	Free-text steering for the reviewer's voice and emphasis.
`reviews.profile`	`chill` \| `assertive`, sets the severity floor.
`reviews.request_changes_workflow`	Post a request changes verdict when blocking findings exist.
`reviews.high_level_summary`	Emit the one-paragraph PR summary.
`reviews.path_filters`	Include/exclude globs (`!` excludes), applied before chunking.
`reviews.path_instructions`	Per-path review guidance injected into the prompt.
`reviews.auto_review.enabled`	Auto-trigger a review on push.
`reviews.auto_review.auto_incremental_review`	Review only the new commits on re-push.
`reviews.auto_review.ignore_title_keywords`	Skip PRs whose title matches (WIP/draft).
`reviews.auto_review.drafts`	Review draft PRs.
`reviews.auto_review.base_branches`	Extra base branches to auto-review, as regex. Your default branch is always reviewed.
`reviews.auto_review.ignore_usernames`	Skip PRs opened by these logins.
`reviews.auto_review.labels`	Label gate, `!` excludes, a bare name requires.
`chat.auto_reply`	Auto-reply to review-thread mentions.
`knowledge_base.opt_out`	Disable the agent-maintained knowledge base.
`knowledge_base.web_search.enabled`	Allow web search while grounding.
`knowledge_base.learnings.scope`	`auto` \| `local` \| `global` learnings recall scope.
`knowledge_base.issues.scope`	Issues recall scope.
`knowledge_base.pull_requests.scope`	Pull-request recall scope.
`knowledge_base.code_guidelines.enabled`	Enforce the repo code-guideline files.
`knowledge_base.code_guidelines.filePatterns`	Globs selecting the guideline files.

Deferred: recognized, not yet applied (the reviewer posts a warning comment)

CodeRabbit key	Planned behavior
`code_generation`	Docstring / unit-test generation.
`issue_enrichment`	Auto-enrichment of linked issues.
`reviews.high_level_summary_instructions`	Custom summary steering.
`reviews.labeling_instructions`	Custom labeling rules.
`reviews.suggested_labels`	Suggest labels on the PR.
`reviews.auto_apply_labels`	Apply the suggested labels automatically.
`reviews.suggested_reviewers`	Suggest reviewers.
`reviews.auto_assign_reviewers`	Assign the suggested reviewers automatically.
`reviews.mutually_exclusive_groups`	Mutually-exclusive label groups.
`reviews.suggested_reviewers_instructions`	Custom reviewer-suggestion rules.
`reviews.slop_detection`	AI-slop detection.
`reviews.post_merge_actions`	Post-merge automation.
`reviews.auto_review.description_keyword`	Description-keyword trigger gate.
`reviews.auto_review.auto_pause_after_reviewed_commits`	Auto-pause after N reviewed commits.
`reviews.pre_merge_checks`	Pre-merge gating checks (title/description length, linked-issue assessment); not enforced yet.
`reviews.finishing_touches`	Docstring / unit-test finishing touches.
`reviews.tools`	The third-party linter/SAST matrix, run the repo's own linters in CI instead.
`knowledge_base.learnings.approval_delay`	Delay before learnings are trusted.
`knowledge_base.automatic_repository_linking`	Auto-link related repositories.
`knowledge_base.linked_repositories`	Cross-repo knowledge linking.

Ignored: recognized platform/cosmetic settings, silently no-op

CodeRabbit key	Why ignored
`early_access`	CodeRabbit early-access opt-in, platform-specific.
`enable_free_tier`	CodeRabbit free-tier flag, platform-specific.
`inheritance`	Org-config inheritance, platform-specific.
`reviews.high_level_summary_in_walkthrough`	Summary placement, cosmetic.
`reviews.high_level_summary_placeholder`	Summary placeholder text, cosmetic.
`reviews.estimate_code_review_effort`	Effort to review estimate, cosmetic.
`reviews.abort_on_close`	Abort an in-flight review on PR close, platform-specific.
`reviews.collapse_walkthrough`	Collapse the walkthrough, cosmetic.
`reviews.sequence_diagrams`	Sequence diagrams, cosmetic.
`reviews.changed_files_summary`	Changed-files table, cosmetic.
`reviews.assess_linked_issues`	Linked-issue assessment table, cosmetic.
`reviews.related_issues`	Related-issues list, cosmetic.
`reviews.related_prs`	Related-PRs list, cosmetic.
`reviews.poem`	The review poem, cosmetic.
`reviews.review_status`	Review in progress status posts, we post our own sticky status.
`reviews.commit_status`	CodeRabbit's commit status. We publish a GitHub check run named `developerz.ai review` instead, on the PR head sha: `queued` when the review is enqueued, `in_progress` while it runs, `completed` when it finishes.
`reviews.fail_commit_status`	Fail that commit status on a blocking review. Our check run concludes `success` or `neutral` and never `failure`, so it reports rather than blocks, unless a maintainer adds `developerz.ai review` to the branch protection as a required check.
`reviews.auto_title_placeholder`	Auto-title placeholder, cosmetic.
`reviews.auto_title_instructions`	Auto-title rules, cosmetic.
`reviews.review_details`	Review details collapsible, cosmetic.
`reviews.review_progress`	Live review-progress edits, cosmetic.
`reviews.in_progress_fortune`	In progress fortune line, cosmetic.
`reviews.enable_prompt_for_ai_agents`	The Prompt for AI Agents block, noise we omit by design.
`reviews.disable_cache`	Disable CodeRabbit's cache, platform-specific.
`chat.art`	ASCII art in chat replies, cosmetic.
`chat.allow_non_org_members`	Allow non-org-member chat, platform-specific.
`chat.integrations`	Chat integrations, platform-specific.
`knowledge_base.jira`	Jira integration, platform-specific.
`knowledge_base.linear`	Linear integration, platform-specific.
`knowledge_base.confluence`	Confluence integration, platform-specific.
`knowledge_base.mcp`	MCP knowledge integration, platform-specific.

Generated from the KNOWN disposition registry (@developerz/review). Run bun run coderabbit:doc to regenerate.

Precedence. If a repo has both .coderabbit.yaml and a review: block in .maintainer.yml, the review: block wins.

Native `review:` block

Add a review: section to .maintainer.yml for the full feature set. The native block is a superset of .coderabbit.yaml:

# yaml-language-server: $schema=https://developerz.ai/schemas/maintainer.v1.json
version: 1

review:
  profile: chill                # chill | assertive | custom
  request_changes: true         # block merge on findings
  learnings: true               # write review learnings back to KB

  anti_noise:
    severity_floor: minor       # drop findings below this level
    max_comments: 30            # cap per-review comment volume

  auto_review:
    base_branches: ["release/.*"]   # regex; your default branch is always reviewed
    ignore_title_keywords: [WIP, "DO NOT MERGE"]

  path_filters:
    - "!**/*.lock"
    - "!dist/**"

  path_instructions:
    - path: "packages/**/*.ts"
      instructions: "Enforce the repo principles in docs/idea/principles.md."

`anti_noise`: quiet by default

The #1 complaint about CodeRabbit is noise. developerz.ai is quiet by default:

Findings below severity_floor are dropped before they reach GitHub.
Volume is capped at max_comments per push (blocking findings always bypass the cap).
Identical findings on re-push are de-duplicated.

Knowledge base write-back (`learnings: true`)

When learnings is enabled, the reviewer writes what it learned from each review back to the repo knowledge base (kind: review-learning). On the next PR in the same repo, the reviewer reads those learnings before commenting. So the bot gets smarter over time without any manual maintenance.

Bot etiquette

By default the reviewer stands down when CodeRabbit is active on the repo, and it never reviews a pull request opened by a bot (Copilot's coding agent, Dependabot, Renovate). No bot-on-bot loops.

Two things get past the CodeRabbit stand-down, and both are deliberate:

review.force: true in .maintainer.yml runs our reviewer alongside an active CodeRabbit. That is the setting for an evidence-based migration, where you want to read both reviews on the same pull request before switching. See the .maintainer.yml reference.
An incumbent that says it did not review. When CodeRabbit reports a commit status declaring it was rate-limited, it has told us this head goes unreviewed, so we review it. Every other gate still applies: a bot-authored PR still defers, and your draft, base-branch, title and label rules are not overridden by someone else's outage.

Uninstalling the other bot is one way to activate the native reviewer. It is not the only way.

Triggering a review

Reviews trigger automatically on every push to a PR. To re-run on the same commit:

# MCP (from Claude Code / Claude Desktop)
review rerun --repo owner/repo --pr-number 42

rerun re-dispatches the LATEST review run for that pull request, so it needs one to exist: a PR we have never reviewed is an error, not a first review. review status lists the runs. See the MCP verb reference.

Review output

The reviewer posts:

High-level summary, one paragraph, what changed and why.
Inline comments, per-hunk findings at the diff line.
A sticky status comment, edited in place from "review under way" to the verdict.

We write no commit status. The verdict lives in the sticky comment and, on paid tiers, in the merge gate the platform applies itself. We do publish one check run, named developerz.ai review on the pull request's head sha (see reviews.commit_status above): it reports rather than blocks, concluding success or neutral and never failure, so adding it to your branch protections as a required check is your choice to make and not a default.

Every comment includes the disclosure footer and is logged to the audit trail.