AI Diff Reviewer
FeaturedOne review methodology for CI and your coding agent.
AI Diff Reviewer is an LLM-driven code reviewer with two surfaces. In CI it runs as a composite GitHub Action — inline comments, suggestion blocks, severity-based gating, and a clean PR timeline. Locally it installs as a coding-agent skill so you can review the current branch before you push. Pin `@v2` on both sides and the default prompt stays in sync. Formerly published as AI PR Reviewer.
5
coordinated capabilities — review, setup, extension, open-pr, apply-review
2
surfaces — Action + agent skill
4
LLM providers (Anthropic, Claude Code, Cursor, Codex)
MIT
licensed, end to end
Sub-skills
One skill pack. Every verb your agent needs.
Each sub-skill maps 1:1 to a public Dailybot API endpoint. Composable, coherent, and documented — the way your agent expects.
review
Run a local review of the current branch's diff using the same methodology and severity model as the CI Action. Ask “Review my current branch” before you push.
generate-extension
Author a repo-tailored `.review/extension.md` so house rules layer on top of the shipped default prompt — shared by local skill and CI when wired.
setup
Install and configure the GitHub Action via a guided wizard — provider, strictness, triggers, labels — and write `.github/workflows/pr-review.yml`. Also the reference manual for every action.yml input.
open-pr
Draft a Conventional-Commits title and structured PR body from the current branch's diff, then create or edit the PR with `gh`.
apply-review
Read the CI review posted on the open PR, present findings in the same format as a local review, and walk through each finding to apply, defer, or skip — with per-finding consent.
Why it works
The bits that make it feel like a teammate.
Local ↔ CI parity
The skill's `prompt.md` is byte-identical to the Action's default prompt at the same tag. Pin `@v2` on both surfaces and share `.review/extension.md` so laptop and Actions stay aligned.
Severity-based gating
Every finding is `critical`, `warning`, or `info`. Configure which severities gate the CI check. Ship faster on info-only reviews; block on critical.
One extension file, both surfaces
House rules live in `.review/extension.md` (legacy paths still accepted). CI and the local skill read the same file so team standards do not drift.
Provider choice you control
Anthropic (default), Claude Code, Cursor, and Codex. Bring your own API key — the Action never proxies through Dailybot.
Setup wizard + input reference
Say “Set up AI Diff Reviewer for this repo” and the skill walks six questions into a tailored workflow. Ask “what does strictness do?” and it answers from the shipped reference without opening action.yml.
MIT + fully forkable
Fork it, wire a private model, extend the severity contract — the code and licence say yes.
How Dailybot connects
Pair it with Deep Work Plan and the Agent Skill when you want reviewed work to land in the same standup feed your team already reads. The skill itself keeps local and CI review on one methodology — findings stay on the PR where humans already look.
Built for
Compatible agents
Install
Two commands and your agent is a teammate.
Install the Dailybot CLI once — it authenticates your session and every skill calls the same binary underneath. Then add the skill to whichever AI CLI you use.
Step 1
Install the CLI (recommended baseline)
One command. Sets up the `dailybot` binary and prepares your local auth.
$ curl -fsSL https://cli.dailybot.com/install.sh | bashStep 2
Install in your AI CLI of choice
Every major AI CLI reads skills from your project's `.agents/skills/` folder. Pick your CLI, run the command, and the skill is available in every future session.
npx skills add DailybotHQ/ai-diff-reviewer --skill ai-diff-reviewername: PR review
on:
pull_request:
branches: [main]
types: [opened, synchronize, labeled]
concurrency:
group: pr-review-${{ github.event.pull_request.number }}
cancel-in-progress: true
jobs:
review:
runs-on: ubuntu-latest
timeout-minutes: 15
permissions:
contents: read
pull-requests: write
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- uses: DailybotHQ/ai-diff-reviewer@v2
with:
api-key: ${{ secrets.ANTHROPIC_API_KEY }}
github-token: ${{ secrets.GITHUB_TOKEN }}
provider: anthropic
model: claude-sonnet-4-6
strictness: block-on-critical
prompt-extension-file: .review/extension.md
applied-label: pr-reviewed
skip-review-label: skip-ai-review
pr-description-mode: autocomplete
complexity-labels-enabled: truehttps://github.com/marketplace/actions/ai-diff-reviewerIn practice
What teams actually do with it.
01
Review before you push
Run the skill locally, fix what matters, then open the PR. CI confirms with the same methodology instead of surprising you in the morning.
02
Fast catch-up on medium-sized PRs
Humans still own architecture and taste. The reviewer clears the class of issues that do not need a human eye — obvious typos, missing null checks, style drift — before anyone opens the tab.
03
Standards without a Slack fight
Configure severity thresholds and let the check gate the merge. Teams stop arguing about style in chat — the check either fails on critical, or it does not.
04
Close the loop after CI
Once the Action posts findings, `apply-review` walks you through each one — apply, defer, or skip — without surprise commits or pushes.
FAQ
The questions we hear the most.
Is this the same as AI PR Reviewer?
Yes — renamed. The GitHub repository `DailybotHQ/ai-pr-reviewer` redirects to `DailybotHQ/ai-diff-reviewer`. Use `@v2` and the new name going forward.
Do I need the GitHub Action to use the skill?
No. Flow A is local-only — review on your branch without CI. Flow B adds the Action for dual-surface parity. The setup sub-skill installs CI when you want it.
Which LLM providers are supported?
Anthropic (default), Claude Code, Cursor, and Codex. Configure via the Action inputs / skill setup. You bring your own key.
Where does the code get sent?
To whichever LLM provider you configure — the Action never proxies through Dailybot. Your API key, your data, your choice of provider.
Does it replace human review?
No. It handles the class of feedback that does not need a human eye so humans focus on architecture, correctness, and taste.
How does it fit with Deep Work Plan?
DWP's Security Review can optionally run the local AI Diff Reviewer pass and append findings. Same severity model; critical findings follow the existing Security Review contract.
What it is
AI Diff Reviewer is an LLM-driven code reviewer with two surfaces: a GitHub Marketplace Action for pull-request CI, and a coding-agent skill for local “review my branch” passes. Five coordinated capabilities — review, generate-extension, setup, open-pr, apply-review — cover the full loop from house rules to merge gate.
Why teams use it
Because “which reviewer is looking at my code?” should have an answer you can inspect, and because local and CI should not disagree about standards. MIT-licensed, developed in the open, no black-box behavior. Fork it, wire it to a private model, extend the severity contract — the code and licence say yes.
How it works with Dailybot
The skill stands alone — you do not need Dailybot to run reviews. When you also use the Dailybot Agent Skill and Deep Work Plan, reviewed work can report into the same standup feed, and DWP Security Review can invoke the local reviewer as an additive pass. Open-source detail: /open-source/ai-diff-reviewer.
Ship agent work your team can actually see.
Install the skill in your favorite AI CLI and every action your agent takes lands in the same standup your humans already read.
Related skills
Dailybot Agent Skill
The official cross-agent skill that turns any AI coding CLI — Claude Code, Cursor, Codex, Gemini, Copilot — into a real teammate on Dailybot. Fourteen capabilities mapped 1:1 to the public API.
Deep Work Plan
The flagship agent methodology from Dailybot. Turn any ambiguous multi-step goal into a numbered, atomic, validated plan every AI coding agent can execute — one gated task at a time.