Guide · Agent skill
How to use the Review Triage Phase agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
Review Triage Phase is an agent skill that reads the saved review state of a pull request and helps you decide what to do with each review comment. For every comment or review body it records whether to address, defer or dismiss it, and it writes the decisions to a validated JSON file and a readable markdown file. This guide explains what the skill does, how to install it, how to ask for it, and what it needs before you start.
Review Triage Phaseprisma/orm · Apache-2.0 Download the skill Quick start
- 1Download the ZIP. Download the skill ZIP from the directory page.
- 2Unzip the skill. Unzip it into ~/.claude/skills/ for personal use or into a project's .claude/skills/ folder. Alternatively, upload it under Settings → Capabilities → Skills in the Claude apps.
- 3Run the fetch phase. Make sure review-state.json exists in the output directory by running /review-fetch-phase <PR_URL> [output-dir] first.
- 4Ask for triage. Send a request with the PR URL, for example: /review-triage-phase <PR_URL> [output-dir].
- 5Track deferred work. Confirm every defer action has a Linear issue and that the thread reply links to the ticket.
- 6Check and render. Let the skill validate review-actions.json with --require-final and render review-actions.md, then read it before continuing.
What the Review Triage Phase skill makes the agent do
When you ask the agent to triage a pull request's review feedback, the skill has it read the saved review state and turn each review comment or review body into a structured action item. The agent then decides, for each item, whether to address it, defer it, or dismiss it.
Deferred items must be tracked in a Linear ticket and linked from a thread reply. The result is a validated review-actions.json file and a review-actions.md file. The skill covers only the triage step; it does not fetch reviews or implement the fixes.
- Reads review-state.json produced by the review-fetch-phase skill
- Creates one action item per review comment or review body
- Records a decision for each item: address, defer or dismiss
- Creates Linear tickets for deferred work and links them from thread replies
- Validates review-actions.json and renders review-actions.md
Install the skill by downloading the ZIP
Download the ZIP for the skill from the directory page. Unzip it into one of these locations, depending on whether you want it available everywhere or only in one project:
For a personal install available to all your projects, unzip it into ~/.claude/skills/. For a single project, unzip it into that project's .claude/skills/ folder.
If you use the Claude apps instead, upload the skill under Settings → Capabilities → Skills.
- Personal: ~/.claude/skills/
- Project only: .claude/skills/ inside your project
- Claude apps: Settings → Capabilities → Skills (upload)
Check the requirements before you run it
The skill needs a few things in place. Missing any of them will stop the workflow early.
The skill expects a review-state.json file in the output directory. That file is produced by the review-fetch-phase skill, which typically needs GitHub access. Creating Linear tickets for deferred work requires a Linear account or API access. The scripts are .mjs files that use node:test, so Node.js must be installed. The output must be untracked by git, so run the work in a git checkout or a Jujutsu workspace so the artifact-ignore guard can verify this.
- Node.js (scripts are .mjs and use node:test)
- review-state.json from review-fetch-phase (typically needs GitHub access)
- Linear account or API access for deferred work
- A Git checkout or Jujutsu workspace for the artifact-ignore guard
Trigger the skill with a natural request
You can ask the agent in plain language to triage a pull request's review comments. Include the PR URL. If you want the outputs in a specific folder, name that folder too. The skill's argument hint is [pr-url] [output-dir].
If you do not give an output directory, the skill derives one from the PR: wip/reviews/<owner>_<repo>_pr-<number>/. Run the fetch step first if review-state.json is missing, using /review-fetch-phase <PR_URL> [output-dir].
- Triage the review comments on https://github.com/<owner>/<repo>/pull/<number>
- Run only the triage phase for this PR and write results to wip/reviews/<folder>/
- Decide which review comments to address now and which to defer
/review-triage-phase <PR_URL> [output-dir]Run the workflow steps the skill follows
The skill runs a fixed sequence. It first enforces the artifact-ignore guard, then bootstraps a canonical review-actions.json from the review state. The triager edits those scaffolded actions in place rather than rebuilding the file. Deferred work gets Linear tickets, then the file is validated with the final flag and rendered to markdown.
Triage is only complete when no decisions are still pending. Each review thread target is answered through a thread reply, not a PR-level review.
- Guard: confirm the output is untracked
- Bootstrap: scaffold review-actions.json from review-state.json
- Triage: decide address, defer or dismiss for each item
- Track: create Linear tickets and link them in thread replies
- Validate: check the JSON with --require-final
- Render: produce review-actions.md
node ./scripts/validate-review-actions.mjs --in <output-dir>/review-actions.json --require-finalExample requests and what you get back
A typical run on a PR with many automated comments starts with a request naming the PR. The agent returns the paths to review-actions.json and review-actions.md, then suggests the next step, which is the implement phase.
Review bodies can hold several findings at once, for example when an automated reviewer bundles outside-diff-range comments, actionable comments and nitpicks into one body. The triager splits these into separate action items instead of dismissing the whole body.
- Request: 'Triage the review feedback on this PR and defer anything bigger than a one-line fix.'
- Result: review-actions.json and review-actions.md paths, plus Linear links for deferred items
- Next step: /review-implement-phase <PR_URL> [output-dir]
Safety notes: scripts and network access
This skill runs scripts and uses the network. The bootstrap, validation and render steps are Node.js scripts in the skill's scripts folder, and the triager agent is allowed to write files, read files, run Bash commands and fetch web pages. Linear ticket creation also talks to an external service.
Review the outputs before anything is posted. The triage is an automated judgement and should be checked by a human before replies are posted to GitHub. Review artifacts are generated files, so keep them out of git.
- Scripts run locally with Node.js; the agent can also use Bash and WebFetch
- Linear and GitHub access happen over the network
- Have a human check decisions before replies are posted
- Keep output directories ignored by git
Tips for getting good triage results
Run the fetch phase on a current copy of the PR so the review state is up to date. Group related deferred comments into one Linear ticket where it makes sense, since the skill allows one or more tickets. Read the review-actions.md file before moving to the implement phase.
The skill is scoped to the prisma/orm review-framework setup. The scripts depend on sibling skill paths and a Linear integration, so adapting it to a different project will take changes.
- Refresh review-state.json before triaging a PR that has changed
- Group related deferred comments into one Linear ticket
- Read review-actions.md before running the implement phase
- Do not expect it to work unchanged outside the prisma/orm review-framework setup
What people use it for
- Working through a large batch of automated review comments on a PR and sorting them into address, defer or dismiss.
- Splitting a bundled CodeRabbit-style review body into separate action items instead of dismissing it wholesale.
- Creating Linear tickets for larger changes raised in review while fixing small items now.
- Producing a readable review-actions.md summary for a maintainer to approve before the implement phase.
Frequently asked questions
How do I install the review-triage-phase skill?
Download the ZIP from the directory page and unzip it into ~/.claude/skills/ for personal use, or into a project's .claude/skills/ folder. In the Claude apps, you can upload it under Settings → Capabilities → Skills.
What does review-triage-phase need to run?
It needs Node.js, a review-state.json file from the review-fetch-phase skill, and typically GitHub access for that fetch. It also needs Linear access to create tickets for deferred work and a Git checkout or Jujutsu workspace for the artifact-ignore guard.
Is the review-triage-phase skill free?
The source does not state pricing or licence terms beyond the Apache-2.0 licence listed for the repository. Check the licence in the repository before using or redistributing it.
Can I use this skill outside the prisma/orm review-framework?
The source says it is not meant for use outside the prisma/orm review-framework setup, because the scripts depend on sibling skill paths and a Linear integration. Adapting it elsewhere would require changes.
Why does the skill say I need review-fetch-phase first?
The triage step reads review-state.json, which the review-fetch-phase skill produces. If that file is missing, the skill tells you to run /review-fetch-phase <PR_URL> [output-dir] first.
Should I trust the triage decisions automatically?
No. The triage is an automated judgement, so a human should check the decisions before replies are posted. Triage is only complete when there are zero pending decisions, and the output is validated with --require-final.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use this skill if you are a maintainer or contributor in the prisma/orm review-framework who needs to sort a large batch of PR review comments into address, defer or dismiss, and you have already run the fetch step. Pick something else if you have not generated review-state.json, work outside that framework, or do not have Linear and GitHub access, since the workflow depends on all three.
Download the skill