Official agent skill

Code Review

by JetBrains in JetBrains/youtrackdb

Review code, test, and workflow-machinery changes across multiple dimensions using specialized agents with triage-based selection.

OfficialApache-2.0Auto-check passedDevelopment

Install Code Review

skills CLI
$ npx skills add JetBrains/youtrackdb --skill code-review -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install JetBrains/youtrackdb code-review --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/JetBrains/youtrackdb.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/code-review .claude/skills/code-review && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
code-review
GitHub stars
437
Token cost
~9.6k tokens
SKILL.md length
3,767 words
Files
1
Skills in repo
16
Repo updated
First seen
Licence
Apache-2.0

At a glance

Review code, test, and workflow-machinery changes across multiple dimensions using specialized agents with triage-based selection.

  • Works in 7 steps: Determine what to review → Detect the base branch → Gather the review context → …
  • Tasks that involve Code review
  • SKILL.md covers Reading workflow files (TOC…, Step 1: Determine what to review, Step 2: Detect the base branch and Step 3: Gather the review…, plus 5 more sections
  • Calls git and gh; reaches github.com

What it does

Code Review is an agent skill from JetBrains/youtrackdb, published by the product's own GitHub organization. Review code, test, and workflow-machinery changes across multiple dimensions using specialized agents with triage-based selection.

Its SKILL.md is about 9.6k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Code review. The repository describes itself as: YouTrackDB is a general-use object-oriented graph database with storage format native to handle graph relations. YouTrackDB supports Gremlin queries and ACID transactions. YTDB… The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Code review

Example prompts

  • “/code-review”

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Determine what to review
  2. Detect the base branch
  3. Gather the review context
  4. Filter non-reviewable files
  5. Triage — categorize changes and select relevant agents
  6. Dispatch selected review agents
  7. Synthesize the results

What it can do on your machine

Read from SKILL.md and the folder at commit 94c4ac0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Code Review loads about 9.6k tokens when it runs. Until then it costs about 36 tokens; SKILL.md has 3,767 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~36
When it runs · the whole SKILL.md, loaded when a task matches
~9.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from JetBrains/youtrackdb at commit 94c4ac0, republished under its Apache-2.0 licence (© JetBrains). 3,767 words, ~9,563 tokens.

Download SKILL.mdSave it as .claude/skills/code-review/SKILL.md (or your agent's skills folder).
name
code-review
description
Review code, test, and workflow-machinery changes across multiple dimensions using specialized agents with triage-based selection.
argument-hint
[branch | commit-range | uncommitted | PR-number]
user-invocable
true

Reading workflow files (TOC protocol)

When you Read any file under .claude/workflow/ or .claude/skills/, follow the protocol in conventions.md §1.8:

  1. Read the TOC region: from <!--Document index start--> to <!--Document index end--> (read to the closing delimiter, not a fixed line count). If the file has no TOC region (a file whose only ## heading is this bootstrap block carries none, per §1.8(d)), read the file in full.
  2. Match TOC rows where Roles contains any of your roles (or your role is any, or the row's Roles is any) AND Phases contains any of your phases (or your phase is any, or the row's Phases is any).
  3. Use Read(offset, limit) to read only matched sections; if no row matches your role/phase, the file holds nothing for you — do not read further.

Your role: orchestrator. Your phase: 3B or 3C (the review phase that invoked this skill).

Inline refs you find inside workflow files carry the same name:roles:phases suffix; apply file-level filtering before opening: a ref matches when any of your roles is in its roles and any of your phases is in its phases, your own any on either axis matches every ref on that axis, and a ref whose own roles or phases is any matches you. Backtick-wrapped refs carry no suffix; open or skip them at your discretion.

<!--Document index start-->
SectionRolesPhasesSummary
§Step 1: Determine what to revieworchestrator3B,3CResolve the review target from the argument or, when empty, from the branch's PR or its commits ahead of develop.
§If $ARGUMENTS is provided:orchestrator3B,3CSix argument shapes: branch, commit range, last-N-commits, uncommitted, PR ref, or an unparseable input.
§If $ARGUMENTS is empty:orchestrator3B,3CFall back to the branch's open PR, then to commits ahead of develop, then ask the user when neither resolves.
§Step 2: Detect the base branchorchestrator3B,3CPick the comparison base: a PR's baseRefName, develop for a bare branch, or none for a range or uncommitted review.
§Step 3: Gather the review contextorchestrator3B,3CCollect changed files and commit log, and write the full diff to a unique /tmp file each agent reads on demand.
§For branch or PR review:orchestrator3B,3CThe git diff and log commands that build the changed-file list, diff file, and commit log for a branch or PR target.
§For commit range:orchestrator3B,3CThe git diff and log commands for a commit-range review target.
§For uncommitted changes:orchestrator3B,3CThe git diff commands for an uncommitted-changes target, with the no-commit-history sentinel for the log.
§PR description (if available):orchestrator3B,3CThe gh command that reads the PR body for context, when a PR is associated with the target.
§Step 4: Filter non-reviewable filesorchestrator3B,3CList the generated-code paths to skip and pass the filter note to every dispatched agent.
§Step 5: Triage — categorize changes and select relevant agentsorchestrator3B,3CCategorize each changed file, map categories to review agents, and log the triage decision before dispatch.
§5a: Categorize each changed fileorchestrator3B,3CThe category table mapping file signals to domains; a file may carry several categories.
§5b: Map categories to agentsorchestrator3B,3CLaunch rules for the 16 review agents across code, test, and workflow groups, keyed on detected categories.
§5c: Log your triage decisionorchestrator3B,3CPrint the triage summary naming detected categories, selected agents, and skipped agents before launching.
§5d: Edge casesorchestrator3B,3CLast-matching-row resolution for category combinations: workflow-only, docs-only, build-config, tests, mixed.
§Step 6: Dispatch selected review agentsorchestrator3B,3CLaunch selected agents in parallel with a scope-filtered file list and the group-specific prompt template.
§Prompt template — code-review and test-review groupsorchestrator3B,3CThe prompt body for the code and test review groups, including the PSI-over-grep tooling rule for Java symbols.
§Prompt template — workflow-review grouporchestrator3B,3CThe prompt body for the workflow-review group, noting PSI does not apply to markdown, shell, and JSON files.
§Handling missing fieldsorchestrator3B,3CTreat the missing-PR and uncommitted sentinels as no signal; do not infer requirements from their absence.
§Step 7: Synthesize the resultsorchestrator3B,3CMap sub-agent severities, deduplicate, attribute, and summarize into one unified report, not a concatenation.
§Handling agent failures and empty outputorchestrator3B,3CRecord failed reviewers, propagate preface notes, emit All clear when empty, and remove the temp diff file.
§Output formatorchestrator3B,3CThe synthesized report layout: failed reviewers, assessment, blockers, should-fix, suggestions, notes, and questions.
§Important rulesorchestrator3B,3CStanding rules: gh CLI for GitHub, parallel dispatch, no self-added findings, no severity softening, large-diff abort.
<!--Document index end-->

Review code, test, and workflow-machinery changes across multiple dimensions by dispatching to specialized review agents and synthesizing their findings. Production code, test code, and workflow files (skills, agents, hooks, settings, prompts, CLAUDE.md, plan/design artifacts) are reviewed in one pass with triage-driven agent selection.

Use $ARGUMENTS as the review target if provided (branch name, commit range, or "uncommitted").

Step 1: Determine what to review

<!-- roles=orchestrator phases=3B,3C summary="Resolve the review target from the argument or, when empty, from the branch's PR or its commits ahead of develop." -->
If $ARGUMENTS is provided:
<!-- roles=orchestrator phases=3B,3C summary="Six argument shapes: branch, commit range, last-N-commits, uncommitted, PR ref, or an unparseable input." -->
  1. Branch name (e.g., ytdb-605-unified-edges): Review all changes on that branch that are absent from the base branch.
  2. Commit range (e.g., abc123..def456): Review that specific range.
  3. "last N commits" (e.g., last 3 commits): Review HEAD~N...HEAD.
  4. "uncommitted" or "working tree": Review uncommitted changes (git diff HEAD).
  5. PR number or URL (e.g., #42 or https://github.com/.../pull/42): Fetch PR details and review its diff.
  6. None of the above (malformed input, non-existent branch, unresolvable PR, free-form phrase): Report what you tried to parse, then ask the user for a valid target. Do not guess.
If $ARGUMENTS is empty:
<!-- roles=orchestrator phases=3B,3C summary="Fall back to the branch's open PR, then to commits ahead of develop, then ask the user when neither resolves." -->
  1. Check if the current branch has an open PR:
    bash
    gh pr list --head $(git branch --show-current) --json number,title,body,baseRefName,url --limit 1
  2. If a PR exists, use it as the review target (the PR's base branch becomes the comparison base).
  3. If no PR exists, check if the current branch differs from develop:
    bash
    git log develop..HEAD --oneline
  4. If there are commits ahead of develop, review those.
  5. If the branch IS develop or has no commits ahead, ask the user what to review. Treat the user's reply as if it were $ARGUMENTS and restart Step 1.

Step 2: Detect the base branch

<!-- roles=orchestrator phases=3B,3C summary="Pick the comparison base: a PR's baseRefName, develop for a bare branch, or none for a range or uncommitted review." -->

The base branch determines what "new changes" means:

  1. If reviewing a PR: use the PR's baseRefName (fetched via gh pr view).
  2. If reviewing a branch (no PR): default to develop.
  3. If reviewing a commit range or uncommitted changes: no base branch needed.

Step 3: Gather the review context

<!-- roles=orchestrator phases=3B,3C summary="Collect changed files and commit log, and write the full diff to a unique /tmp file each agent reads on demand." -->

Based on the review mode, collect the changed-file list and commit log inline, but write the full diff to a temp file so each agent can Read it on demand instead of receiving it interpolated into its prompt. This keeps per-agent prompt size bounded and removes the diff-size ceiling that inline interpolation would impose.

Use a unique /tmp filename to avoid collisions with concurrent Claude Code agents on the same host (per the user-global rule). Generate the suffix once and reuse it for the whole dispatch:

bash
# Generate a unique suffix for this review's temp file
DIFF_FILE=/tmp/claude-code-review-diff-$$.txt   # or use $(uuidgen)
For branch or PR review:
<!-- roles=orchestrator phases=3B,3C summary="The git diff and log commands that build the changed-file list, diff file, and commit log for a branch or PR target." -->
bash
git diff {base}...HEAD --name-only           # → CHANGED_FILES
git diff {base}...HEAD > "$DIFF_FILE"        # → DIFF_FILE
git log {base}..HEAD --oneline               # → COMMIT_LOG
For commit range:
<!-- roles=orchestrator phases=3B,3C summary="The git diff and log commands for a commit-range review target." -->
bash
git diff {start}..{end} --name-only          # → CHANGED_FILES
git diff {start}..{end} > "$DIFF_FILE"       # → DIFF_FILE
git log {start}..{end} --oneline             # → COMMIT_LOG
For uncommitted changes:
<!-- roles=orchestrator phases=3B,3C summary="The git diff commands for an uncommitted-changes target, with the no-commit-history sentinel for the log." -->
bash
git diff HEAD --name-only                    # → CHANGED_FILES
git diff HEAD > "$DIFF_FILE"                 # → DIFF_FILE

For uncommitted changes there is no commit log; set COMMIT_LOG to the literal sentinel "(uncommitted changes — no commit history)".

PR description (if available):
<!-- roles=orchestrator phases=3B,3C summary="The gh command that reads the PR body for context, when a PR is associated with the target." -->
bash
gh pr view {number} --json body --jq '.body'

Store the collected context:

  • DIFF_FILE — absolute path to the temp file containing the full diff (e.g., /tmp/claude-code-review-diff-12345.txt). Each agent reads this file via the Read tool.
  • CHANGED_FILES — the list of changed file paths
  • COMMIT_LOG — the commit history, or the uncommitted-changes sentinel above
  • PR_DESCRIPTION — the PR body text, or the literal string "No PR associated with these changes." if absent
  • REVIEW_SCOPE — human-readable description of what's being reviewed (e.g., "Branch ytdb-605-unified-edges vs develop (15 commits, 23 files)")

The temp file is ephemeral — remove it at the end of Step 7 (synthesis) so orphans don't accumulate. The unique suffix prevents collision with concurrent agents while the review is in flight.

Step 4: Filter non-reviewable files

<!-- roles=orchestrator phases=3B,3C summary="List the generated-code paths to skip and pass the filter note to every dispatched agent." -->

Before dispatching, note files that should be skipped:

  • Files under core/src/main/java/com/jetbrains/youtrackdb/internal/core/sql/parser/
  • Generated Gremlin DSL classes
  • Files under generated-sources/ or generated-test-sources/

Include this filter note in the context passed to agents.

Step 5: Triage — categorize changes and select relevant agents

<!-- roles=orchestrator phases=3B,3C summary="Categorize each changed file, map categories to review agents, and log the triage decision before dispatch." -->

Before dispatching agents, perform a quick triage pass over the entire diff (both production and test code) to determine which review dimensions are actually relevant. This avoids wasting time on agents that have nothing meaningful to review.

5a: Categorize each changed file
<!-- roles=orchestrator phases=3B,3C summary="The category table mapping file signals to domains; a file may carry several categories." -->

Scan the diff and assign one or more categories to every changed file — production code, test code, and other files alike:

CategorySignals
storage-engineFiles in storage/, cache/, wal/, StorageComponent subclasses, page read/write logic, DiskStorage, WriteCache, ReadCache, LogSequenceNumber, double-write log
concurrencysynchronized, Lock, Atomic*, volatile, StampedLock, ReentrantLock, thread pools, ConcurrentHashMap, CompletableFuture, shared mutable state, @GuardedBy, ConcurrentTestHelper, CountDownLatch, CyclicBarrier
index-data-structuresFiles in index/, B-tree, hash index, SBTree, CellBTree, histogram, IndexEngine
network-serverFiles in server/, driver/, Gremlin Server, protocol handling, TLS/SSL, authentication, session management
sql-queryFiles in sql/ (excluding parser/), query execution, command handlers, SELECT/INSERT/UPDATE/DELETE logic
gremlinFiles in gremlin/, traversal steps, YTDBGraph* classes, TinkerPop integration
public-apiFiles in com.jetbrains.youtrackdb.api, YourTracks, YouTrackDB interface
serializationRecord serializers, binary format, property map encoding/decoding
crash-durabilityWAL operations, crash simulation, durable StorageComponent recovery, page corruption handling, transaction atomicity under failure, LogSequenceNumber manipulation, double-write log, Java assert statements in production code
configurationGlobalConfiguration, config parameters, system properties
tests-onlyChanges exclusively in test files with no production code changes
build-configpom.xml, CI workflows, Maven profiles, Docker configs
workflow-machineryFiles under .claude/ (skills, agents, hooks, scripts, settings, workflow rules, workflow prompts, output styles, docs), project root CLAUDE.md, all files under docs/adr/<dir>/ (plan/design artifacts in _workflow/ and the durable design-final.md / adr.md)
docs-onlyMarkdown documentation under docs/ excluding docs/adr/<dir>/, plus comments-only changes
otherFiles matching no category above (e.g., .gitattributes, miscellaneous root files). Triaged as a no-op — no agents dispatch on this category.

A file can belong to multiple categories (e.g., a lock change in storage code is both storage-engine and concurrency). Production and test files in the same domain should share the same categories. workflow-machinery is exclusive with docs-only: any file under .claude/ or docs/adr/<dir>/ is workflow-machinery; anything else under docs/ is docs-only.

5b: Map categories to agents
<!-- roles=orchestrator phases=3B,3C summary="Launch rules for the 16 review agents across code, test, and workflow groups, keyed on detected categories." -->

There are 16 specialized review agents in three groups:

Code-review agents (review production code):

AgentLaunch when ANY of these categories are present
review-code-qualityAlways launched (unless docs-only is the ONLY category)
review-bugsAlways launched (unless docs-only or build-config are the ONLY categories)
review-concurrencyconcurrency is present on any changed file
review-crash-safetycrash-durability
review-securitynetwork-server, public-api, sql-query, serialization, configuration, OR when new dependencies are added in pom.xml
review-performancestorage-engine, index-data-structures, concurrency, serialization, sql-query, gremlin

review-bugs owns every defect findable by single-threaded sequential reasoning (logic, null safety, resource leaks, RID handling, state-machine / lifecycle); review-concurrency owns every defect whose detection needs reasoning about two or more threads interleaving (races, visibility / publication, lock-ordering / deadlock, compound-op atomicity). When review-bugs, reasoning sequentially, meets concurrent-looking code that review-concurrency was not triaged onto, it emits a one-line "concurrency triage gap" note so the orchestrator can launch review-concurrency.

Test-review agents (review test quality and coverage gaps):

AgentLaunch when
review-test-qualityAlways launched (unless docs-only or build-config are the ONLY categories)
review-test-structureAny test files are changed (reviews isolation, readability, setup/teardown of test code itself)
review-test-concurrencyconcurrency is present on any changed file (production or test)
review-test-crash-safetycrash-durability

review-test-quality carries both the behavior sub-protocol (whether tests verify real behavior, assertion depth) and the completeness sub-protocol (corner cases, boundary conditions); it keeps both the TB and TC finding prefixes verbatim.

Categories from both production and test code count for the test-review side — for example, if production code adds a new synchronized block but tests don't exercise threading, review-test-concurrency should still launch to flag the gap.

Workflow-review agents (review changes to the workflow machinery itself):

AgentLaunch when
review-workflow-consistencyworkflow-machinery is present — always launched for this group
review-workflow-prompt-designworkflow-machinery AND any changed file matches .claude/skills/*/SKILL.md, .claude/agents/*.md, or .claude/workflow/prompts/*.md
review-workflow-instruction-completenessworkflow-machinery AND any changed file matches .claude/skills/*/SKILL.md, .claude/agents/*.md, .claude/workflow/*.md, or .claude/workflow/prompts/*.md
review-workflow-hook-safetyworkflow-machinery AND any changed file matches .claude/hooks/*.sh, .claude/scripts/**, or .claude/settings*.json
review-workflow-context-budgetworkflow-machinery is present — always launched for this group. The agent decides whether the diff affects any of three axes (always-loaded surface, load-on-demand discipline, or instant per-operation consumption) and emits an empty findings list when none are affected.
review-workflow-writing-styleworkflow-machinery AND any changed file matches .claude/**/*.md, root CLAUDE.md, or docs/adr/**/*.md

The workflow-review agents focus on .claude/, root CLAUDE.md, and plan artifacts under docs/adr/<dir>/_workflow/. They ignore Java code changes — the code-review and test-review agents handle those.

Complexity never changes which agents this step selects. Selection is domain-only: a category is present → its agent launches, identically at every per-track complexity level. The per-track complexity tag (read by the workflow's Phase-C callers, not by this standalone skill) moves only the rigor dial — what terminates the Phase-C review-iteration loop. Blockers loop until clear at every complexity level. The should-fix depth scales with the tag: low never lets should-fix drive iteration, medium allows up to three iterations, high is uncapped. The uncapped loops terminate by no-progress detection rather than a fixed cap (see review-iteration.md § Limits and track-code-review.md § Review loop). The floor plus the domain-matched set is never suppressed by a low complexity; complexity only shortens or lengthens iteration, never drops a selected reviewer. The standalone /code-review skill takes no complexity input and always runs the domain-selected set once.

5c: Log your triage decision
<!-- roles=orchestrator phases=3B,3C summary="Print the triage summary naming detected categories, selected agents, and skipped agents before launching." -->

Before launching agents, output a brief triage summary so the user can see the reasoning:

### Triage summary
- **Categories detected**: storage-engine, concurrency, index-data-structures
- **Code agents selected**: review-code-quality, review-bugs, review-concurrency, review-crash-safety, review-performance
- **Test agents selected**: review-test-quality, review-test-structure, review-test-concurrency, review-test-crash-safety
- **Workflow agents selected**: (none — no workflow-machinery changes)
- **Agents skipped**: review-security (no network/API/SQL/config/dependency changes)
Show full SKILL.md (1,727 more words)Show less
5d: Edge cases
<!-- roles=orchestrator phases=3B,3C summary="Last-matching-row resolution for category combinations: workflow-only, docs-only, build-config, tests, mixed." -->

The rules below cover combinations not handled by the per-row tables above. Where a combination matches more than one row, the last matching row wins. Workflow-machinery cases are listed first because workflow-only diffs are common and short-circuit the entire code/test agent dispatch.

Staged-path normalization (run first). On a workflow-modifying plan the authored .claude/... edits live under docs/adr/<dir>/_workflow/staged-workflow/.claude/... (per §1.7) while the live tree stays at develop's state. The Step 5b workflow-review globs name live .claude/... paths, so a staged path matches none of them. Three glob-gated reviewers therefore miss and fail to launch: review-workflow-prompt-design, review-workflow-instruction-completeness, and review-workflow-hook-safety. (review-workflow-consistency and review-workflow-context-budget always run for this group; review-workflow-writing-style already fires via its docs/adr/**/*.md glob, and since its .claude/**/*.md glob also matches the normalized path, it fires regardless of which form this row is evaluated against.) Before evaluating the Step 5b per-agent triggers against the workflow-machinery subset of the diff, normalize each changed path: a path matching the anchored prefix docs/adr/<any-dir>/_workflow/staged-workflow/(\.claude/…) is replaced by its captured .claude/… remainder; the match is anchored after the docs/adr/<dir>/ head (the <dir> segment is variable). A path that does not match this exact anchored prefix passes through unchanged, including one that merely contains .claude/ lower down. A staged file then evaluates exactly as its live counterpart would, and the three glob-gated reviewers launch on the staged edit. Normalization runs ahead of the Step 5b glob match only; it does not edit the globs themselves and does not change the Step 5a file-set categorization (a staged file is already workflow-machinery by the docs/adr/<dir>/ rule).

  • If the only category present is workflow-machinery: Skip all code-review and test-review agents (no Java code or tests to evaluate). Launch the workflow-review agents selected by the workflow-side rules.
  • If the only categories are docs-only and workflow-machinery (any mix): Treat as workflow-machinery-only — skip code-review and test-review agents, launch the workflow-review group on the workflow-machinery files.
  • If the diff mixes workflow-machinery with production-code or test categories: launch each group's agents on its in-scope files. Each group is dispatched with a pre-filtered IN_SCOPE_FILES list (see Step 6) so cross-contamination is bounded.
  • If the only category present is docs-only: Skip all agents. Just report that only end-user documentation changed and no review is needed.
  • If the only category present is build-config: Launch only review-code-quality (to check for misconfigurations) and review-security (to check for dependency changes). Skip all test-review and workflow-review agents.
  • If the only category present is tests-only: Launch review-code-quality and review-bugs (test logic can have bugs too), plus review-concurrency if the concurrency category is present, plus the full test-review set selected by the test-side rules above.
  • If the only categories are build-config and tests-only (e.g., a CI tweak plus the test it enables): Launch review-code-quality, review-security, and the full test-review set. The tests-only rule wins over build-config's "skip test-review" because the tests are the substantive change.
  • If a file matches no category (e.g., .gitattributes): assign it the other category — it does not dispatch any agent. If other is the only category present, skip all agents and report that nothing reviewable changed.
  • If in doubt about whether an agent is relevant: launch it. False positives (an agent finding nothing) are better than false negatives (missing a real issue).

Step 6: Dispatch selected review agents

<!-- roles=orchestrator phases=3B,3C summary="Launch selected agents in parallel with a scope-filtered file list and the group-specific prompt template." -->

Launch the selected agents in parallel using the Agent tool. Each agent receives a scope-filtered context: build IN_SCOPE_FILES per agent group from the triage categories assigned in Step 5a.

  • Code-review group: files categorized as anything other than docs-only, workflow-machinery, or other. (Files categorized as build-config stay in scope — review-code-quality and review-security need to see pom.xml and CI changes per Step 5d.)
  • Test-review group: files that match the agent's individual launch rule plus any file categorized tests-only.
  • Workflow-review group: files categorized as workflow-machinery.

The IN_SCOPE_FILES list narrows the agent's focus; the full DIFF is still passed so the agent can read context lines around each change.

The Tooling section differs by group. Use the code/test variant for the code-review and test-review groups, and the workflow variant for the workflow-review group.

Prompt template — code-review and test-review groups
<!-- roles=orchestrator phases=3B,3C summary="The prompt body for the code and test review groups, including the PSI-over-grep tooling rule for Java symbols." -->
Review the following changes from your specialized perspective.

## Review Scope
{REVIEW_SCOPE}

## In-Scope Files
{IN_SCOPE_FILES}

## PR Description
{PR_DESCRIPTION}

## Commit Log
{COMMIT_LOG}

## Changed Files
{CHANGED_FILES}

## Skip These Files (generated code)
- core/src/main/java/com/jetbrains/youtrackdb/internal/core/sql/parser/*
- Any files under generated-sources/ or generated-test-sources/
- Generated Gremlin DSL classes

## Tooling
Use **mcp-steroid PSI find-usages / find-implementations / type-hierarchy
via `steroid_execute_code`, not grep**, for any reference-accuracy
question about a Java symbol in this diff (callers/overrides/usages of
a method, field, class, or annotation; whether a slot is genuinely
unused; whether a renamed symbol still has stale references; for test
review, which production methods a test exercises and where else they
are called). Grep is acceptable for filename globs, unique string
literals, and orientation reads, but the load-bearing answer behind a
finding must be PSI-backed when the mcp-steroid MCP server is
reachable per the SessionStart hook (`steroid_list_projects` once at
the start confirms the open project matches the working tree). Fall
back to grep with an explicit reference-accuracy caveat in the finding
only when mcp-steroid is unreachable. See `CLAUDE.md` § MCP Steroid →
"Grep vs PSI — when to switch" for the full routing rule.

## Diff
The full diff is at: {DIFF_FILE}
Read it with the `Read` tool before forming findings. For diffs over
2000 lines, read the file in chunks using the `offset` and `limit`
parameters. Do not infer diff content from {CHANGED_FILES} alone — the
file list does not show what changed inside each file.
Prompt template — workflow-review group
<!-- roles=orchestrator phases=3B,3C summary="The prompt body for the workflow-review group, noting PSI does not apply to markdown, shell, and JSON files." -->
Review the following changes from your specialized perspective.

## Review Scope
{REVIEW_SCOPE}

## In-Scope Files
{IN_SCOPE_FILES}

## PR Description
{PR_DESCRIPTION}

## Commit Log
{COMMIT_LOG}

## Changed Files
{CHANGED_FILES}

## Tooling
PSI does not apply — these are markdown, shell, and JSON files, not Java
symbols. Use `Read` on the in-scope files and on any referenced skill,
agent, hook, or output-style file. Use `Grep` for "is this string
mentioned anywhere else in the repo" questions. The Java-targeted
mcp-steroid PSI rule does not apply to workflow-machinery review.

## Diff
The full diff is at: {DIFF_FILE}
Read it with the `Read` tool before forming findings. For diffs over
2000 lines, read the file in chunks using the `offset` and `limit`
parameters.
Handling missing fields
<!-- roles=orchestrator phases=3B,3C summary="Treat the missing-PR and uncommitted sentinels as no signal; do not infer requirements from their absence." -->

If PR_DESCRIPTION is the literal string "No PR associated with these changes." or COMMIT_LOG is the uncommitted-changes sentinel, treat the field as carrying no signal. Do not infer requirements from the absence.

The 16 possible agents (launch only those selected in Step 5):

Code-review agents:

  1. review-code-quality — code quality, conventions, readability
  2. review-bugs — bugs, logic errors, null safety, resource leaks, RID handling, state-machine / lifecycle (single-threaded sequential reasoning)
  3. review-concurrency — races, visibility / publication, lock-ordering / deadlock, compound-op atomicity (multi-thread interleaving reasoning)
  4. review-crash-safety — WAL correctness, durability, crash recovery
  5. review-security — injection, auth, data exposure, dependencies
  6. review-performance — algorithmic complexity, allocations, lock contention, I/O

Test-review agents: 7. review-test-quality — behavior-driven quality (assertion precision, exception testing) plus completeness (corner cases, boundary conditions, test data quality) 8. review-test-structure — isolation, independence, readability, documentation 9. review-test-concurrency — concurrent behavior testing quality 10. review-test-crash-safety — crash/recovery test quality, production assert statements

Workflow-review agents: 11. review-workflow-consistency — cross-file references, threshold sync, hook wiring, recipe paths, glossary drift 12. review-workflow-prompt-design — prompts-as-prompts-to-an-LLM: description discriminability, deterministic decision rules, clean-context invocation, sub-agent delegation annotations 13. review-workflow-instruction-completeness — branch coverage, gate resume paths, sub-agent input/output handshake, error recovery, loop termination 14. review-workflow-hook-safety — shell hygiene, /tmp collision safety, hook performance, secret hygiene, JSON schema validity 15. review-workflow-context-budget — always-loaded surface (descriptions, CLAUDE.md, SessionStart stdout), load-on-demand discipline, instant per-operation consumption (sub-agent delegation, output caps, /tmp staging, targeted reads) 16. review-workflow-writing-style — house-style: AI-tells, banned sentence and analysis patterns, BLUF lead, soft section length cap with template-bound exemptions, repo-anchored voice.

Set subagent_type to the agent name. The agent's frontmatter declares its model; do not override it from the dispatch call unless the user explicitly asks for a different model.

Step 7: Synthesize the results

<!-- roles=orchestrator phases=3B,3C summary="Map sub-agent severities, deduplicate, attribute, and summarize into one unified report, not a concatenation." -->

After all selected agents complete, produce a unified review report. Do NOT simply concatenate the outputs. Instead:

  1. Map sub-agent severities to synthesized severities. Most sub-agents emit findings under Critical / Recommended / Minor, but several older code-review agents use legacy scales (review-bugs and review-concurrency share one, review-crash-safety and review-security each have their own). Translate as:

    • Critical → blocker (all agents)
    • Recommended → should-fix (most agents)
    • Minor → suggestion (most agents)
    • Likely Issues → should-fix (review-bugs, review-concurrency)
    • Potential Concerns → suggestion (review-bugs, review-concurrency)
    • Concerning → should-fix (review-crash-safety)
    • Informational → suggestion (review-crash-safety)
    • High → blocker (review-security)
    • Medium → should-fix (review-security)
    • Low → suggestion (review-security)

    Apply this mapping verbatim. The "do not soften" rule below means: do not demote a sub-agent's blocker-level finding to anything below blocker. The only legal override is promoting (e.g., raising a should-fix to blocker because another sub-agent's blocker-level finding on the same line escalates the severity).

  2. Deduplicate. Findings merge when they share the same (file, line-range, root issue). Different review dimensions on the same line merge into one finding listing all dimensions. Different lines do not merge. Workflow-review findings on a shell or JSON file may merge with code-review findings on the same file when they describe the same root issue.

  3. Attribute. For each finding, indicate which review dimension(s) identified it. Use a short label (e.g., [code-quality], [bugs], [concurrency], [test-quality], [test-crash-safety], [workflow-consistency], [workflow-hook-safety], [workflow-writing-style]).

  4. Summarize. Write a brief overall assessment (2-3 sentences). Cover whichever of code, tests, and workflow machinery actually appear in the diff. Do not write about a dimension that produced no findings.

Handling agent failures and empty output
<!-- roles=orchestrator phases=3B,3C summary="Record failed reviewers, propagate preface notes, emit All clear when empty, and remove the temp diff file." -->
  • If a sub-agent returns empty output, errors out, or times out, add it to a ### Failed reviewers section at the top of the report with a one-line note and continue. Do not block the synthesis.
  • If a sub-agent emits agent-specific preface sections beyond Critical / Recommended / Minor (for example, review-workflow-context-budget emits Always-loaded delta and Instant-consumption delta tables when any axis is affected), propagate them under a ### Reviewer notes section after the severity blocks rather than dropping them silently. These preface sections are optional: review-workflow-context-budget omits them in the no-impact case, and absence is not a failure.
  • If all selected agents return zero findings, emit an explicit ### All clear block under the overall assessment instead of an empty report.
  • After the synthesized report is produced (whether with findings or ### All clear), remove the temp diff file from Step 3: rm "$DIFF_FILE". The file is no longer needed once every sub-agent has returned.
Output format
<!-- roles=orchestrator phases=3B,3C summary="The synthesized report layout: failed reviewers, assessment, blockers, should-fix, suggestions, notes, and questions." -->
markdown
## Review: {REVIEW_SCOPE}

### Failed reviewers
[Omit if none. One line per failed agent.]

### Overall assessment
[2-3 sentences. Cover whichever of code, tests, and workflow machinery
produced findings — skip the dimensions that returned clean.]

### Blockers
[Must fix before merge]

1. **[Dimension]** `path/to/file.ext` (line X-Y)
   - **Issue**: ...
   - **Suggestion**: ...

### Should-fix
[Should fix before merge]

1. **[Dimension]** `path/to/file.ext` (line X-Y)
   - **Issue**: ...
   - **Suggestion**: ...

### Suggestions
[Recommended improvements]

1. **[Dimension]** `path/to/file.ext` (line X-Y)
   - **Issue**: ...
   - **Suggestion**: ...

### Reviewer notes
[Agent-specific preface sections propagated verbatim. Omit if none.]

### Questions for the author
[Clarifying questions aggregated from all reviewers. Omit if none.]

If a priority level has no findings, omit it entirely. If all priority levels are empty, replace them with ### All clear and a one-line note.

Important rules

<!-- roles=orchestrator phases=3B,3C summary="Standing rules: gh CLI for GitHub, parallel dispatch, no self-added findings, no severity softening, large-diff abort." -->
  • Always use gh CLI for GitHub API calls, not WebFetch.
  • All selected agents must run in parallel — do not wait for one before launching the next.
  • Only launch agents selected by the triage step — do not launch agents for irrelevant dimensions.
  • Do not add your own review findings — only synthesize what the agents report.
  • Do not soften or dismiss agent findings — keep Critical at blocker, Recommended at should-fix, Minor at suggestion. Promotion is allowed when another sub-agent's higher-severity finding on the same line argues for it.
  • If the diff is very large (>500 files or >50,000 lines), abort and ask the user to scope the review more narrowly (by directory, module, or commit range). The file-based diff hand-off in Step 3 lifts the per-prompt limit, so the practical ceiling is the per-agent context window — only very large reviews need user-side scoping.
  • Standalone command: This command uses the same dimensional review agents as the Phase 3 workflow but with a different context structure (PR description and commit log instead of implementation plan and track file). Severity scale uses the same blocker/should-fix/suggestion levels as the workflow (see .claude/workflow/review-iteration.md).

© JetBrains, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/code-review of JetBrains/youtrackdb.

Open the folder on GitHubat commit 94c4ac0

Compare with similar skills

Code Review next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Code Review compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Code Review this skillJetBrains/youtrackdb437—~9.6kAutomated safety check: PassApache-2.0
PR Babysitteropeninterpreter/openinterpreter69k3 repos~4.2kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k5 repos~1.1kAutomated safety check: PassMIT
Backend Code Reviewlangflow-ai/langflow156k—~3.5kAutomated safety check: NotesMIT
Understand Diff AnalysisEgonex-AI/Understand-Anything86k1 repos~1.4kAutomated safety check: PassMIT
Mole Bug Patternstw93/Mole70k—~2kAutomated safety check: PassGPL-3.0

Similar skills

  • PR Babysitter

    openinterpreter/openinterpreter

    Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.

    69k GitHub starsUsed in 3 repos~4.2k tokens
    DevelopmentAuto-check passed
  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 5 repos~1.1k tokens
    DevelopmentAuto-check passed
  • Backend Code Review

    langflow-ai/langflow

    Review backend code for quality, security, maintainability, and best practices based on established checklist rules.

    156k GitHub stars~3.5k tokensUpdated today
    DevelopmentAuto-check: notes
  • Understand Diff Analysis

    Egonex-AI/Understand-Anything

    Reads your git changes or a pull request against a prebuilt knowledge graph of the project to explain what changed, which components are affected and what is risky.

    86k GitHub starsUsed in 1 repo~1.4k tokens
    DevelopmentAuto-check passed
  • A catalog of recurring bug shapes in the Mole Mac cleaner, used to review safety-sensitive diffs for deletion safety, unbounded commands, shell traps and weak tests.

    70k GitHub stars~2k tokensUpdated today
    DevelopmentAuto-check passed
  • Backend Code Review

    langgenius/dify

    Reviews backend code under api/ for concrete, reproducible defects, routes to rule packs for architecture, schema, repositories and SQLAlchemy, and ranks findings from P0 to P3.

    158k GitHub stars~676 tokensUpdated today
    DevelopmentAuto-check passed

More from JetBrains/youtrackdb

All 16 skills in this repo
  • Readability Feedback

    JetBrains/youtrackdb

    Official

    Audit a finished design document for hard-to-read or hard-to-understand paragraphs, then harden the house-style rules so future design docs avoid them.

    437 GitHub stars~2.3k tokensUpdated today
    Auto-check passed
  • Review Docs

    JetBrains/youtrackdb

    Official

    Review documentation files for grammar, factual accuracy, and query correctness.

    437 GitHub stars~3k tokensUpdated today
    Auto-check passed
  • Edit Design

    JetBrains/youtrackdb

    Official

    Apply an edit to design.md or design-mechanics.md through the mutation discipline: apply → auto-review → iterate → present.

    437 GitHub stars~21k tokensUpdated today
    Auto-check passed
  • Migrate Workflow

    JetBrains/youtrackdb

    Official

    Migrate a branch's docs/adr/<dir/workflow/ artifacts by replaying workflow-format commits from the per-artifact stamp base through HEAD.

    437 GitHub stars~12k tokensUpdated today
    Auto-check passed
  • Run Jmh Benchmarks Hetzner

    JetBrains/youtrackdb

    Official

    Provision a Hetzner CCX33 server, deploy the project, run JMH benchmarks, collect results, and destroy the server.

    437 GitHub stars~3.7k tokensUpdated today
    Auto-check: warnings
  • Review Workflow PR

    JetBrains/youtrackdb

    Official

    Review a workflow-style PR's design, plan, and track files in research-mode Q&A; auto-records observations and submits a line-anchored review via gh api.

    437 GitHub stars~11k tokensUpdated today
    Auto-check passed

Categories

Questions about Code Review

What does Code Review do?

Review code, test, and workflow-machinery changes across multiple dimensions using specialized agents with triage-based selection. Code Review is an agent skill from JetBrains/youtrackdb, published by the product's own GitHub organization. Review code, test, and workflow-machinery changes across multiple dimensions using specialized agents with triage-based selection.

When should I use Code Review?

Code Review fits situations like: tasks that involve Code review.

How do I install Code Review in Claude Code?

Run `npx skills add JetBrains/youtrackdb --skill code-review -a claude-code`. Or copy the skill folder (.claude/skills/code-review in JetBrains/youtrackdb) into .claude/skills/code-review in your project. Claude Code loads it when a task matches its description.

How do I install Code Review in Codex?

Run `npx skills add JetBrains/youtrackdb --skill code-review -a codex`. Or copy the skill folder (.claude/skills/code-review in JetBrains/youtrackdb) into .agents/skills/code-review in your project. Codex loads it when a task matches its description.

Can I use Code Review in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add JetBrains/youtrackdb --skill code-review -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/code-review, .gemini/skills/code-review, .github/skills/code-review and .opencode/skills/code-review in your project.

What does Code Review need to run?

Going by SKILL.md and its folder, Code Review needs the command-line tools its instructions call (git and gh).

Does Code Review access the network?

SKILL.md names 1 domain. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Code Review safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Code Review use?

Code Review is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Code Review use?

About 9.6k tokens (SKILL.md is roughly 38k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Code Review?

Skills that share tags, products or a category with Code Review: PR Babysitter (openinterpreter/openinterpreter, 69k stars), Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars), Backend Code Review (langflow-ai/langflow, 156k stars) and Understand Diff Analysis (Egonex-AI/Understand-Anything, 86k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Code Review?

JetBrains (a GitHub organization, an official publisher) maintains it in JetBrains/youtrackdb, which has 437 GitHub stars. The repository holds 16 skills in this directory. The repository was last updated on October 8, 2026.

Source: JetBrains/youtrackdb on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.