Differential review skill from Trail of Bits: what it does and how to install it

Source: trailofbits/skills · Maintainer: community: Trail of Bits · License: CC-BY-SA-4.0 · Checked: 24 October 2026

What is the differential review skill?

The differential review skill turns Claude Code into a security reviewer for a pull request, commit or diff: it ranks changed files by risk, reads git history behind removed code, counts callers to size the blast radius, flags changes with no tests, and writes the findings to a markdown report file. It is for developers and security engineers who want more than "looks good to me" on risky changes.

It comes from Trail of Bits, the security auditing firm, as one plugin in its skills marketplace. The plugin README names Omar Inuwa as the author, and the plugin manifest lists version 1.1.4.

The skill's description reads: "Performs security-focused differential review of code changes. Adapts analysis depth to codebase size, uses git blame for context, calculates blast radius by counting callers, checks test coverage of modified code, and generates a markdown report. Use when reviewing a PR, commit, or diff for security vulnerabilities, checking whether a change re-introduces a previously fixed bug, asking what else a change could break, or finding which modified code has no test covering it."

As of 24 October 2026, its skills.sh page listed about 8,700 installs (snapshot, 24 October 2026).

What does it do?

The SKILL.md sets five principles: risk first, every finding backed by evidence, depth adapted to codebase size, honest coverage limits, and always a report file. It then runs a fixed workflow:

1. Pre-Analysis. Build baseline context, using the audit-context-building skill if it is installed.
2. Phase 0, triage. List changed files, measure the codebase, and score each file HIGH, MEDIUM or LOW risk.
3. Phase 1, changed code. Read before and after versions, run git log -S and git blame on removed code, and check whether re-added code was once removed for security.
4. Phase 2, test coverage. A new function with no tests moves from MEDIUM to HIGH risk.
5. Phase 3, blast radius. Count callers of each modified function: 1 to 5 is LOW, 6 to 20 MEDIUM, 21 to 50 HIGH, more than 50 CRITICAL.
6. Phase 4, deep context. Map the full flow of each HIGH risk function.
7. Phase 5, adversarial analysis. Model an attacker and build a concrete exploit scenario.
8. Phase 6, report. Write a nine-section markdown report.

Depth scales with size. A codebase under 20 files gets a deep read of all dependencies, 20 to 200 files gets a focused read of one hop out, and more than 200 files gets a surgical pass on critical paths only.

Risk levels are spelled out. HIGH covers auth, crypto, external calls, value transfer and validation removal. MEDIUM covers business logic, state changes and new public APIs. LOW covers comments, tests, UI and logging. The skill also has a table of excuses it should not accept, such as "Small PR, quick review", answered with "Heartbleed was 2 lines".

Red flags trigger adversarial analysis even in a quick triage: code removed from commits labeled "security", "CVE" or "fix", removed access control modifiers, validation removed without a replacement, new external calls without checks, and a HIGH risk change with more than 50 callers.

What's in the skill folder:

• SKILL.md: principles, quick reference tables, decision tree, checklist and red flags.
• methodology.md: Pre-Analysis and Phases 0 to 4, with the git and grep commands.
• adversarial.md: Phase 5 attacker modeling and exploitability ratings.
• reporting.md: the report template, file naming and where to save it.
• patterns.md: vulnerability patterns such as regressions, reentrancy, access control bypass, overflow and front-running.
• agents/openai.yaml and an icon: display metadata for Codex and ChatGPT workspace imports.

The plugin adds two more pieces outside the skill folder: a /differential-review:diff-review command that takes <pr-url|commit-sha|diff-path> [--baseline <ref>], and an adversarial-modeler subagent that the skill hands HIGH risk changes to in Phase 5.

How do you install it?

Claude Code plugin. The repo README adds the marketplace, which is named trailofbits, and suggests /plugin menu to browse it:

/plugin marketplace add trailofbits/skills
/plugin install differential-review@trailofbits

The plugin@marketplace form is the standard syntax from the Claude Code plugin docs. The plugin install is the only route that brings the diff-review command and the adversarial-modeler agent. Plugin skills are namespaced, so the skill appears as /differential-review:differential-review.

Codex. Also from the README:

codex plugin marketplace add trailofbits/skills
codex plugin add differential-review@trailofbits

Just the skill folder. The skills CLI command, exactly as shown on skills.sh:

npx skills add https://github.com/trailofbits/skills --skill differential-review

That copies the folder to .claude/skills/differential-review/ in your project, or ~/.claude/skills/differential-review/ with -g, the standard Claude Code skill locations. Codex and Cursor read the same SKILL.md format; see Codex skills and Cursor skills.

For the Pre-Analysis step, also install audit-context-building@trailofbits. The skill works without it but says to use it when it is available.

How do you use it?

Point it at a concrete change and, for a big codebase, name the baseline.

Example prompts (suggestions, not quotes from the repo):

• /differential-review:diff-review https://github.com/acme/api/pull/482
• Do a security review of git diff main..feature/auth-changes. Focus on anything that touches session handling.
• /differential-review:diff-review a1b2c3d --baseline v2.4.0
• This PR removes a check in withdraw(). Find out why it was added and whether removing it reopens an old bug.
• Which functions changed in this branch have no test covering them? Rate the risk of each.

The README's own example asks it to "Review the security implications of this PR" and passes git diff main..feature/auth-changes on the next line.

Requirements: a git repo with history (the method depends on git blame and git log -S), and the GitHub CLI if you review PRs by number, since triage uses gh pr view. There are no API keys and no packages to install.

Expect a long run on a large change. The skill's own examples estimate about 30 minutes for a small PR, 3 to 4 hours for 80 files with 12 HIGH risk changes, and 6 to 8 hours for a 450 file auth rewrite.

Tips and limits

From the files and pages linked, not from testing:

• Security audits on skills.sh. As of 24 October 2026, the skill showed Pass from Gen Agent Trust Hub, Socket and Snyk, all audited 17 September 2026.
• What runs. The folder has no scripts. The SKILL.md frontmatter lists allowed-tools: Read Write Grep Glob Bash, which per the Claude Code skills docs lets Claude use those tools without asking during the turn that invokes the skill. Expect git, grep, find and gh commands in your repo.
• It writes a file. The report goes to your project folder first, then your Desktop, then ~/.claude/skills/differential-review/output/, named like <PROJECT>_DIFFERENTIAL_REVIEW_<DATE>.md. It only falls back to chat if writing fails.
• Smart contract flavor. Many examples and patterns (Solidity files, onlyOwner, reentrancy, front-running) come from blockchain audits. The method still applies to web and backend code, but expect some examples that don't match your stack.
• issue-writer is not in the repo. The SKILL.md mentions an issue-writer skill for turning findings into audit reports; no skill by that name is in trailofbits/skills as of 24 October 2026.
• When not to use it. The skill itself says to skip greenfield code with no baseline, documentation-only changes, formatting changes, and cases where you only want a quick summary.
• License. CC-BY-SA-4.0: you can share and adapt it with credit to Trail of Bits, and adapted versions you share must use the same license.

Save it in your Kipt library

In Kipt, open Skills and paste the skill's GitHub folder link into the import box. For a repo with many skills, Kipt shows a list to pick from, so you can take audit-context-building in the same pass. You can also drop the folder or a .zip. Your skills live in your own private GitHub repo and install into Claude Code or Codex with one command:

npx skills add https://github.com/<you>/<repo>.git --all -g

Keep the CC-BY-SA notice with any copy you change. Kipt is not affiliated with Trail of Bits.

Similar skills

• Semgrep skill: Trail of Bits' static analysis skills, a good first pass before a diff review.
• Code review skill: a general review for correctness and design, not only security.
• Security and hardening skill: rules for writing secure code before it reaches review.
• Receiving code review skill: how the agent should handle the findings once the report lands.