review · insilico-org, reviewer — Claude Code skill: plan reviews and installation
This Claude Code skill checks PLSI plan predictions against follow-up results and revises decisions. It runs when a review is due or new results arrive.
MIT ★ 93 updated 2026-11-15
npx skills add Insilico-org/plsi --skill review -a claude-codeWhat review does
The skill compares results with predictions in active PLSI plans, checks adherence and side effects, then proposes continuing, changing, or stopping a plan. It summarizes prediction calibration and marks outcomes as untested when low adherence means the prediction was not properly assessed.
After an adverse event, it screens the plan again; a serious finding can lead to a proposal to stop the action. PLSI Nostradamus drafts any replacement plan, and a decision is recorded only after PLSI relays the user's choice. The PLSI workflow and the plsi command must be available.
What it helps with
- compare follow-up results with plan predictions
- separate untested predictions from misses caused by low adherence
- factor side effects into a plan review
- summarize prediction calibration and decide what happens next
Example prompts for the agent
- Run the PLSI plan review and collect any missing follow-up results.
- Here are the results since the plan started. Compare them with its predictions and propose a decision.
- The weekly check-in found a side effect. Review the plan.
How to install review
1Skills CLI (Vercel)
npx skills add Insilico-org/plsi --skill review -a claude-code2Manually: put the files in place
~/.claude/skills/review/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/review/
1Skills CLI (Vercel)
npx skills add Insilico-org/plsi --skill review -a codex2Manually: put the files in place
.agents/skills/review/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Insilico-org/plsi --skill review -a cursor2Manually: put the files in place
.cursor/skills/review/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Insilico-org/plsi skills/reviewer/review2Manually: put the files in place
.github/skills/review/SKILL.md1Skills CLI (Vercel)
npx skills add Insilico-org/plsi --skill review -a gemini-cli2Platform CLI
gemini skills install https://github.com/Insilico-org/plsi --path skills/reviewer/reviewManually: put the files in place
.devin/skills/review/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about review
How do I install review in Claude Code?
Run npx skills add Insilico-org/plsi --skill review -a claude-code. The skill file is at ~/.claude/skills/review/SKILL.md.
What does the review skill do?
It evaluates PLSI predictions against follow-up results, checks adherence and side effects, then drafts a decision to continue, modify, or stop a plan.
What does review need to run?
The PLSI workflow and the plsi command must be available. For a plan change, PLSI Nostradamus drafts the replacement, and the decision is recorded after PLSI relays the user's choice.
Source text
SKILL.md · MIT
---
name: review
description: Use as PLSI Reviewer when PLSI asks for a review - predictions are due (weekly check-in, review date reached) or the user brings follow-up results for an adopted plan; collects adherence and side effects, scores predictions, revises the plan and reports calibration.
---
# PLSI review
## When to use
- The "PLSI check-in" routine found due or awaiting predictions.
- The user sends follow-up results, or a plan reached its review date.
- PLSI's mid-plan check (weekly check-in or a record card) reported low adherence or a side effect: run steps
2-10 without waiting for the review date.
- An insight PLSI forwards (digest, research note, Mothership): check it against the active plans' predictions and
actions only (`plsi plan list`), skip step 2, and return `continue` or a `modify` proposal.
## Steps
1. See what is due and what the user has not told yet; each active plan's `plan.json` is in the request's `files`
(step 4 screens it; missing: say so in a `result`):
```bash
plsi due --instance <instance>
plsi plan list --instance <instance>
```
2. **Adherence and side effects first.** Unless the request already carries them for the whole window, send ONE
`question` handoff to PLSI per review with, for each active plan: missing measurements; per action the count of
doses/sessions done of those planned since adoption and the longest gap; any side effect or adverse event since adoption
(what, when it started, still present, stopped the action?). Wait for the `answer`. PLSI passes the relayed answers to
`processor/intake`; do not list them again in your `result`.
3. The new results reach you through PLSI after PLSI Data Processor recorded them and re-projected every map the plan uses. Check
that the state of each map its predictions name (`map_id`) is current (otherwise say so in a `result`; PLSI has
PLSI Data Processor re-project):
```bash
plsi state show --instance <instance> --map <map_id>
```
4. **Adverse event: re-screen before scoring.** Add each reported event as a finding on the action it may belong to
(`caution`, or `block` when serious or when the action must not continue), then screen the adopted plan again:
```bash
plsi screen --instance <instance> --file plan.json --findings findings.json
```
A `block` outcome forces the proposal to `stop` (or a `modify` that drops the action); state the event plainly.
5. Score:
```bash
plsi score --instance <instance>
```
6. **Decide with adherence.** Low adherence = clearly fewer doses/sessions done than the prediction assumed (plan
`method`; about four in five of those planned if none stated); quote the counts ("9 of 12"), not a share.
- A miss with low adherence is reported as **not tested**, not as a failure; propose `continue` or `modify`
(simpler schedule, later window), never `stop` for lack of effect.
- A hit with low adherence is reported with that caveat.
- A miss with adequate adherence is a failure of the prediction; apply the `revision_rule`.
7. Summarize calibration in bullets: scored and missed counts, observed within-interval fraction vs the nominal level, mean absolute error, beat-persistence rate and direction accuracy, per coordinate and overall; list not-tested predictions separately.
8. **Draft the decision** per plan: Continue / Modify / Stop / Complete against the plan's `revision_rule`, with each
prediction's expected value, interval and observed value, adherence and side effects. Before proposing `modify`,
ask PLSI in a `result` to have PLSI Nostradamus draft the replacement PlanInput as its own file, screened and
checked (`nostradamus/plan` step 3), with `nostradamus/trajectory` on it (current course vs revised plan); you
author no plan. Use its files for the decision. List every new caution from step 4 (one line each);
PLSI shows them above the plan's card, and the user's Continue or Modify proceeds on them. `complete` is allowed
only after the review date.
9. Send ONE `result`: scores, adherence, side effects, calibration and one decision question per plan (its cautions
listed above it) and, for `modify`, the replacement's start date; list `trajectory.json` in `files` for a `modify`.
PLSI shows it with `visualizer/dashboard` (scope "plan review").
10. After PLSI's `answer`, write `review.json` (for `modify`, the full replacement under `"replacement"`), apply it and
send a `result` with the new plan status, the voided predictions and, for `modify`, the `replacement_plan_id` and
the user's start date (PLSI has Nostradamus adopt it) with Nostradamus's `trajectory.json` unchanged in `files`, or
plainly what failed. After `stop`, name `nostradamus/trajectory` as follow-up only if a dashboard needs it:
```json
{"decision": "continue", "rationale": "p1 within interval; 12 of 12 sessions done; no adverse effects reported"}
```
```bash
plsi plan review --instance <instance> --plan <plan_id> --file review.json
```
## Rules
- Report misses and wrong predictions as plainly as hits; never reword a miss as a success, and never call an
untested plan a failure.
- Only measurements taken and recorded after adoption, inside the window, count; do not backdate.
- Any adverse event is reported, re-screened and named in the decision, even when the user wants to continue.
- A scored outcome or reported reaction that is a red flag gets a `red_flag:` line (`orchestrator/urgent`) in your
step's one `question` or `result`; propose pausing the action as a revision.
- `stop` and `modify` void predictions whose window has not opened; say so.
- Never record a decision without the user's choice relayed in PLSI's `answer`.
© Insilico-org · MIT · Insilico-org/plsi
Similar skills
All skills for Code review and refactoring →review by other authors comes first.