Skip to main content
skill CX Codex

plan · insilico-org — Claude Code skill: health plans and installation

A Claude Code skill that combines health intervention proposals into one screened plan with explicit predictions. It activates when someone asks what to try, start, change, or compare.

MIT ★ 93 updated 2026-11-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Insilico-org/plsi --skill plan -a claude-code
Open on GitHub

What plan does

The skill turns intervention options into a single plan with predictions for health measures. It gathers evidence through PLSI, verifies cited sources, records findings, and screens the combined actions for risks. Specialist proposals keep their doses and schedules; duplicates are removed, and the plan includes a no-action control.

A current PLSI state is required through plsi state show; without one, the skill reports that an assessment via consultant/assess is needed. It writes the plan to plan.json and saves sources and findings in evidence.json. The screening step also checks care context. With caution: mood-screen-positive, a clinician check comes first, while new supplement and longevity-stack actions are excluded.

What it helps with

  • combine specialist proposals into one intervention plan
  • compare options by predicted changes to a health measure
  • record evidence and findings for proposed actions
  • screen a combined plan for risks and interactions

Example prompts for the agent

  • Compare options for lowering PhenoAge acceleration and draft a plan with predictions.
  • Merge the sleep and nutrition specialists' proposals into one plan.
  • Plan a change to my interventions and define how to assess its result.

How to install plan

1Skills CLI (Vercel)

npx skills add Insilico-org/plsi --skill plan -a claude-code

2Manually: put the files in place

~/.claude/skills/plan/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/plan/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about plan

How do I install plan in Claude Code?

Run npx skills add Insilico-org/plsi --skill plan -a claude-code. The skill file is at ~/.claude/skills/plan/SKILL.md.

What does plan do?

It combines intervention options into one plan, records supporting evidence, screens risks, and adds predictions for health measures.

What does plan need to work?

It needs a current PLSI state, available through plsi state show. If there is no state, it points to an assessment via consultant/assess.

Source text

SKILL.md · MIT
---
name: plan
description: Use as PLSI Nostradamus when PLSI asks for options to improve a coordinate (for example lower PhenoAge acceleration) or relays specialists' dosed proposals - merge them into ONE screened, recorded plan with explicit predictions.
---

# PLSI plan

## When to use

- The user asks what they could try, or wants to start, change or compare interventions.
- A current state exists (`plsi state show`); otherwise say so in a `result` (PLSI has PLSI Health Consultant project it, `consultant/assess`).
- Not when the request `summary` names a `scope:` line (`orchestrator/urgent`) and the plan falls in that area:
  return a `result` that declines it and names the care to point to; draft nothing.
- When the request `summary` or a relayed proposal names `caution: mood-screen-positive` (`orchestrator/urgent`):
  do **not** hard-decline the whole plan. Keep a clinician check as a `test` FIRST; merge Sleep stress practices
  only (no longevity stack / new progressive WHO); surface the exact caution line in the plan `objective` or
  findings and in the `result` `summary`.
- You are the one plan author: specialists only propose. Exercise and substance actions are dosed by PLSI Coach,
  sleep and stress by PLSI Sleep, diet by PLSI Nutritionist, supplement stacks by PLSI Biohacker, patient protocols
  by PLSI Clinical Evidence (physician role); their dosed proposals reach you through PLSI. A domain whose specialist is not on the team is off: do not dose it; say so in
  your `result` so PLSI can offer "Add <bot>?". A general, undosed plan action in that domain (or in a domain no
  specialist owns) is still allowed.

## Steps

1. **Gather evidence on the fly** for each candidate option, reusing what is already known (`shared/team`, Evidence
   speed), then verify every identifier you will cite. If the request names the chosen option(s) (specialists'
   proposals relayed by PLSI, or the user's pick), skip the pick: reuse the proposals' verified claims, search only
   for cross-domain interactions and the screening points, make no oracle asks (no pick question carries their
   clearance) and go to step 2.

   ```bash
   plsi evidence search --source pubmed --query "<intervention> <coordinate> randomized" --limit 10
   plsi evidence search --source europepmc --query "<intervention> <coordinate>"
   plsi evidence search --source ctgov --query "<intervention>"
   plsi evidence search --source openfda --query "<intervention>"
   plsi evidence search --source evipedia --query "<intervention>"
   plsi evidence verify --kind pmid --id <pmid>
   plsi evidence verify --kind doi --id <doi>
   ```

   With the Evipedia MCP connected, use `search_reviews`, `get_conclusion` and `get_metadata` (cite as `{"kind": "evipedia", "id": "<slug>"}`). Model oracles are `model_derived` (cite as `{"kind": "model", "id": "pandaclaw"}` or `"longevity_llm"`). Send `instance`/`map_id` (the saved state leaves the computer) only when the request `summary`
   names the user's oracle approval ("Oracles: allow", or the user's Allow relayed on this thread). Otherwise build the
   options with topic-only asks (`{"prompt": ...}`, no personal data). For "ask each time", add "Send your <map> values
   to <oracle> for a personal check of the chosen option?" to the option-pick `question` below, and make that ask only
   after the `answer` says Send, before step 2. When no pick is needed, stay with topic-only asks; never send a question
   only for oracle consent.

   Write each planned ask to `<PLSI_HOME>/work/<thread>/ask.json` and put it in the step's ONE `question` for PLSI
   to clear with PLSI Data Controller (`controller/egress`); run only the asks the `answer` names as `cleared`,
   unchanged:

   ```bash
   echo '{"prompt": "<question>", "instance": "me", "map_id": "blood_phenoage"}' > ask.json
   plsi oracle pandaclaw --file ask.json
   # L-LLM: a topic ask on the playground, run by PLSI (shared/l-llm)
   ```

   Save the options' sources and findings to `<PLSI_HOME>/work/<thread>/evidence.json`. Put the graded options
   (benefits and risks) in the step's ONE `question` and wait.

2. **Write ONE `plan.json`** (schema `contracts/PlanInput.schema.json`) from the step 1 evidence in `evidence.json`,
   merging every relayed proposal into it (each prediction names the `map_id` of its coordinate, so one plan spans
   every map the proposals predict on; keep each proposal's dose and schedule; drop duplicates; one
   no-action control for the whole plan); screen the combined set in step 3, since cross-domain actions interact;
   search again only for what the chosen option still lacks (a dose, a schedule, a safety point). Under
   `caution: mood-screen-positive`, put the caution line in `objective` (or a findings caution), order the clinician
   `test` first among actions, drop new supplement/longevity-stack actions, and keep only low-intensity stress /
   restorative proposals from Sleep (and Coach NARROW if present):

   ```json
   {"objective": "lower phenoage_acceleration over 90 days",
    "actions": [{"local_id": "a1", "description": "<intervention> <dose> daily", "category": "supplement",
                 "dose": "<dose>", "schedule": "daily"}],
    "claims": [{"local_id": "c1", "statement": "<what the source shows>", "evidence_class": "evidence_backed",
                "sources": [{"kind": "pmid", "id": "<pmid>"}], "supports": ["a1"],
                "effect": {"coordinate": "crp", "direction": "down"}}],
    "predictions": [
      {"local_id": "p1", "map_id": "blood_phenoage", "coordinate": "phenoage_acceleration",
       "target": "change_from_baseline", "horizon_days": 90, "expected": -1.0, "low": -3.0, "high": 0.5, "interval_level": 0.8, "method": "<how you derived it>",
       "evidence_class": "evidence_backed", "basis": [{"kind": "pmid", "id": "<pmid>"}], "driven_by": ["a1"]},
      {"local_id": "p0", "map_id": "blood_phenoage", "coordinate": "phenoage_acceleration",
       "target": "change_from_baseline", "horizon_days": 90, "expected": 0.0, "low": -1.5, "high": 1.5, "method": "no-action control: test-retest variation",
       "evidence_class": "rule_derived", "basis": [{"kind": "rule", "id": "plsi.derive.phenoage"}], "driven_by": []}],
    "revision_rule": {"review_after_days": 90, "continue_if": "p1 within interval or better",
                      "modify_if": "no change and no side effects", "stop_if": "any adverse effect or worse than p0"}}
   ```

3. **Screen with judgment, check, fix.** `plsi screen` sets a floor from the label (term matches); you add what a
   reader sees and a regex misses. Read the care context and the label and literature for each drug or supplement
   action, and write `findings.json` (`{"a1": [{"severity": "caution", "summary": "...", "source": {"kind": "pmid",
   "id": "<pmid>"}}]}`, verified sources only). Your findings can only raise the outcome.

   ```bash
   plsi state show --instance <instance> --map care_context
   plsi screen --instance <instance> --file plan.json --findings findings.json
   plsi plan check --instance <instance> --file plan.json
   ```

   - `block`: drop or replace the action; never argue a block away.
   - `caution`: do not ask now. List each caution in your `result` (one line each, with its source); PLSI shows
     them above its one adoption card (`orchestrator/conduct`), and the user's Start proceeds on every one of them.
     Only after Start set `"acknowledged": true` and an `acknowledgement_note`.
   - Fix ALL other violations `plan check` lists, then re-run it until only unacknowledged cautions remain.
   - Run `screen` and `plan check` again only after changing `plan.json` or `findings.json`, or when a state
     changed (`plan check` reports G1); never as a last check before sending. When a state changes or PLSI Challenger objects,
     change only the actions, claims and predictions it touches, then run them once.

   Run `nostradamus/trajectory` (current course vs with the plan). Save `plan.json`, `findings.json` and
   `trajectory.json` under `<PLSI_HOME>/work/<thread>/` and send a `result` to PLSI: the trajectory brief in `summary`,
   the options, grades, predictions, the no-action control, the cautions and, as the one `questions` item, the start
   date. Add a `red_flag:` line (`orchestrator/urgent`) if the state or evidence shows a critical value or a
   dangerous interaction with a current action. PLSI has PLSI Challenger challenge it (`challenger/challenge`); answer the objections
   once, revising the plan or rebutting with sources. The request carries Challenger's objections on the specialists'
   proposals (Proposals mode): answer each in the draft (drop or lower the dose, or rebut with a source). On an objection to a specialist's dose, drop the action or lower
   its dose (stricter only), citing the objection; a new dose needs its owner, so name `<role>/<skill>` in your
   `result` for PLSI to dispatch. Only if the plan changed, rewrite `trajectory.json` and re-run
   `screen` and `plan check`.

4. **Record and adopt** only after PLSI's `answer` from the one adoption card. Start: set the acknowledgements,
   then record (`plan record` runs every gate) and adopt on the chosen date. For a Review `modify`, PLSI sends the
   `replacement_plan_id` and start date: run only `plan adopt`:

   ```bash
   plsi plan record --instance <instance> --file plan.json
   plsi plan adopt --instance <instance> --plan <plan_id> --start-on 2026-10-21
   ```

   "Change the plan" carries the user's words: change only what they touch (step 3) and send a new `result`. "Not
   yet": record nothing.

   Send a `result`: the plan id, the review date and what to measure at each horizon, or plainly what failed.

## Prediction guidance

- Prefer `phenoage_acceleration` or `change_from_baseline` targets; they cancel ageing and baseline offsets. Add a
  `level` prediction of the same coordinate when the trajectory should draw it (`nostradamus/trajectory` step 5).
- Honest intervals: include measurement noise and the uncertainty of transferring population effects to one person.
- State assumptions (adherence, dose, measurement timing) in `method`.
- Compute expected values of derived targets (clocks, scores) with `plsi calc derive ... --set <input>=<value> --at
  <horizon date>` from the effect sizes you cite; never by hand. Start no-action courses from `base_rate` references.
- Always add one no-action control prediction (`driven_by: []`); it is the bar the plan must beat.

## Rules

- Soft `caution: mood-screen-positive` is durable packaging, not hard `scope:`: clinician/test FIRST, no longevity
  stack, stress practices only; repeat the caution line in the `result` `summary`.
- A proposal that predicts on a quantity no map has: keep the action, put a `processor/add-map` request in
  your `result` and add the prediction once the coordinate exists; never predict on an uninstalled coordinate.
- Re-screen when the plan, the care context (medications, conditions, allergies) or the 7-day screening window changes.
- Cite only identifiers verified with `plsi evidence verify` in the last 30 days (`plan check` enforces it for plan sources only).
- Each action needs a supporting claim at or above the map's `min_evidence_class_for_actions`.
- Prediction coordinates must be predictable map coordinates, in the coordinate's canonical unit.
- Never call `plan record` or `plan adopt` without the user's confirmation relayed by PLSI.

© Insilico-org · MIT · Insilico-org/plsi

Similar skills

All skills for Science and research →

plan by other authors comes first.

plan codewithmukesh Builds an architecture-aware implementation plan for .NET work before code changes begin. Use it for changes spanning layers, modules, or architectural decisions. CX Codex +1 3,900installs plan boshu2 Turns a vague request into one end-to-end slice with an observable result. Runs when planning, breaking down or scoping a change. CX Codex +1 1,500installs plan owainlewis plan breaks down feature specs into end-to-end tasks designed for an agent to finish in a single pull request. Runs before coding begins to turn requirements into ready-to-build work slices. CX Codex +1 788installs plan launchdarkly Generates a tailored LaunchDarkly SDK integration plan from detected repository tech. Chooses server or client libraries, entrypoints, and env variables. CX Codex +1 2,300installs plan hyperb1iss A skill for Claude Code, Codex, Cursor, and other AI coding platforms that breaks down complex work into verifiable tasks and dependencies. Activates when you ask for a plan, request step-by-step breakdown, or ask to decompose a feature. CX Codex +1 606installs doctorg glebis doctorg is a Claude Code skill that answers health, nutrition, training and sleep questions by checking trusted sources and grading the strength of evidence for each claim. CX Codex +1 265installs plan-crafting sentimony The plan-crafting skill turns an approved design or settled requirements into a step-by-step implementation plan with tasks sized at 2–5 minutes. Useful when nothing is coded yet and the order of work needs to be fixed. CX Codex +1 4,100installs ce-plan EveryInc ce-plan builds structured technical implementation plans without touching production code. Useful when scoping features before passing work to execution agents. CX Codex +1 4,000installs ralph-plan mastra-ai ralph-plan — an interactive planning skill for Claude Code and coding agents. It helps build structured ralph-loop commands through guided dialog and codebase exploration. CX Codex +1 2,600installs plan-craft sentimony The plan-craft Claude Code skill turns approved requirements into an ordered implementation plan. It runs before coding when a spec or design has been settled. CX Codex +1 1,900installs alan-plan tryalan-ai alan-plan walks the agent through planning: analyze the task, ask clarifying questions, draft the plan and persist it as an Alan artifact. CX Codex +1 1,800installs

From the same set85

The whole set →
discover The discover Claude Code skill ranks candidate targets for a disease, an aging process, or a drug-repurposing idea. It returns a shortlist with a way to disprove each candidate and an experiment to test it. CX Codex +1 ★ 93repo stars evaluate The evaluate Claude Code skill assesses a gene as a treatment target for a named disease. It gathers evidence on disease links, druggability, safety, and ongoing research. CX Codex +1 ★ 93repo stars import This Claude Code skill imports wearable data into PLSI maps. It runs on requests to load data from Open Wearables, Google Health, or an export file. CX Codex +1 ★ 93repo stars mothership This Claude Code skill prepares research notes and physician registry updates for Longevity Mothership. It can also turn Mothership updates into verified insights for a plan. CX Codex +1 ★ 93repo stars talk This Claude Code skill holds conversations about the user and saves their answers to PLSI records. It runs during setup interviews, scheduled weekly talks, or conversations the user starts. CX Codex +1 ★ 93repo stars clinic This Claude Code skill sets up file exchange between a physician and patients through Google Drive. It handles patient folders, incoming uploads, approved reports, and the clinic dashboard. CX Codex +1 ★ 93repo stars dashboard This Claude Code skill turns PLSI data into an HTML dashboard with charts. It runs when PLSI requests a state, plan, research, or target summary. CX Codex +1 ★ 93repo stars open-wearables This Claude Code skill sets up or repairs an Open Wearables server and its PLSI connection. It runs during server setup or when wearables/import rejects an API key. CX Codex +1 ★ 93repo stars

Project sponsors

Companies that keep this analytics open