Agent skill

Orchestrate

by Aperivue in Aperivue/medsci-skills

A skill your agent uses when the user describes a research goal without naming a skill, or the task spans several skills.

MITAuto-check passedResearch & Science

Install Orchestrate

skills CLI
$ npx skills add Aperivue/medsci-skills --skill orchestrate -a claude-code

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

GitHub CLI
$ gh skill install Aperivue/medsci-skills orchestrate --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/Aperivue/medsci-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/orchestrate .claude/skills/orchestrate && 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
orchestrate
GitHub stars
329
Token cost
~8.1k tokens
SKILL.md length
3,794 words
Files
7 (incl. references)
Skills in repo
54
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when the user describes a research goal without naming a skill, or the task spans several skills.

  • Works in 6 steps: Identify the node for the fork (Nodes… → Render it with the reference's… → Wait for a numeric choice or a control… → …
  • The user describes a research goal without naming a skill
  • SKILL.md covers Available Skills, Classification Logic, Workflow Execution — Dialogue… and Full Pipeline Mode, plus 3 more sections
  • Runs Python scripts from its folder; calls git and gh

What it does

Orchestrate is an agent skill from Aperivue/medsci-skills. Use when the user describes a research goal without naming a skill, or the task spans several skills. Classifies the request, plans the order and routes to the right medsci-skills skill(s) instead of producing their output itself.

Its SKILL.md is about 8.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 8 other files, including reference files (for example `references/data_flow_contract.md`, `references/dialogue_nodes.md` and `references/report_template.md`).

It sits in Research & Science. The repository describes itself as: Agent Skills for medical research — literature search, reporting-guideline & citation checks, statistics, publication figures, submission. Works with Claude Code, Codex, Cursor &… The licence is MIT.

When your agent uses it

  • The user describes a research goal without naming a skill
  • The task spans several skills

Example prompts

  • “/orchestrate”

Requirements

  • Python 3

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Identify the node for the fork (Nodes column of the Multi-skill workflows table).
  2. Render it with the reference's §"Rendering Template": under ~15 lines, unlocks / locks /
  3. Wait for a numeric choice or a control word. One node per turn — never stack two.
  4. Echo the lock in one line before invoking the skill ("Locking: CARE reporting guideline;
  5. Invoke the downstream skill for the chosen option, then return to step 1 for the next fork.
  6. Adapt on skill output. If a result invalidates a prior lock (e.g., /self-review surfaces a

What it can do on your machine

Read from SKILL.md and the folder at commit 3b14ae2. 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

    Ships script files (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • git
    • gh

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

  • Network

    No URLs in SKILL.md. Its commands use git and gh, which can reach the network depending on how they are called.

    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

Orchestrate loads about 8.1k tokens when it runs, and up to ~13k if it reads all its reference files. Until then it costs about 61 tokens; SKILL.md has 3,794 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~61
When it runs · the whole SKILL.md, loaded when a task matches
~8.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~13k

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 Aperivue/medsci-skills at commit 3b14ae2, republished under its MIT licence (© Aperivue). 3,794 words, ~8,133 tokens.

Download SKILL.mdSave it as .claude/skills/orchestrate/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
orchestrate
description
Use when the user describes a research goal without naming a skill, or the task spans several skills. Classifies the request, plans the order and routes to the right medsci-skills skill(s) instead of producing their output itself.
metadata.triggers
orchestrate, research help, what should I do next, where do I start, help me with my paper, run the pipeline, which skill, end-to-end, e2e

Orchestrate Skill

Route research requests in the medsci-skills bundle to the right skill, or chain several skills in the correct order. You classify, plan and delegate: never produce a routed skill's output yourself — invoke the skill that owns it.


Available Skills

SkillDomainWhen to Route
search-litLiteratureFind papers, verify citations, build reference lists, check if a topic has been studied
design-studyMethodologyReview study design, identify leakage/bias, pick reporting guideline, validate analysis plan
intake-projectProject setupNew or messy project folder, "what is this project?", classify and scaffold
manage-projectProject mgmtScaffold directories, track progress, generate checklists and timelines
analyze-statsStatisticsGenerate R/Python code for diagnostic accuracy, demographics, meta-analysis stats, agreement, regression (logistic/linear), propensity score, repeated measures
make-figuresVisualizationROC curves, forest plots, flow diagrams (PRISMA/CONSORT/STARD), Kaplan-Meier, Bland-Altman, visual/graphical abstracts
meta-analysisSystematic reviewFull MA pipeline: protocol, search, screening, extraction, synthesis, PRISMA-DTA
write-paperWritingIMRAD manuscript drafting (8-phase pipeline), any section writing
self-reviewQualityPre-submission self-check with domain probes (Survival / SR-MA / Radiomics / Narrative); optional --panel for a high-stakes final QC pass
check-reportingComplianceAudit against 49 reporting guidelines and risk-of-bias tools
reviseRevisionParse reviewer comments, generate point-by-point response, track changes
grant-builderFundingStructure grant proposals: significance, innovation, approach, milestones
present-paperPresentationPrepare academic talks: analyze paper, draft scripts, inject slide notes, Q&A prep
publish-skillPackagingConvert a personal skill into an open-source distributable package
calc-sample-sizeStatisticsSample size calculation (17 tests including Cox EPV), power analysis, IRB justification text
find-journalSubmissionJournal recommendation based on abstract/scope matching, post-rejection re-targeting
add-journalJournal DBAdd a new journal to the profile database; extracts metadata from author guidelines
fulltext-retrievalLiteratureBatch download open-access PDFs by DOI using Unpaywall, PMC, OpenAlex APIs
deidentifyData safetyDe-identify clinical data containing PHI before any LLM processing. Standalone Python CLI (no LLM).
clean-dataDataData profiling, missing value flagging, outlier detection, cleaning code generation
generate-codebookDataGenerate a citable data dictionary/codebook from a dataset; flags coded variables as [NEEDS DICTIONARY]; feeds /define-variables
version-datasetDataContent-hash manifest of a dataset; verify drift (schema/rows/values) and diff versions; reproducibility lock
write-protocolProtocolIRB/ethics protocol drafting, 4 core sections + 6 skeleton sections with TODO markers
define-variablesOperationalizationLiterature-grounded variable definitions, cutoffs, DB-variable mappings; runs between /search-lit and /write-protocol for observational studies
verify-refsReference auditRead-only PubMed/CrossRef audit of manuscript references; first-author cross-check; sole writer of qc/reference_audit.json. Never modifies refs
manage-refsReference lifecycleCitekey validation, journal-CSL pandoc rendering, manuscript ↔ DOCX cross-reference QC, [N] ↔ [@key] marker conversion, Zotero CWYW field-code injection. Sole writer of manuscript_final.docx, qc/xref_audit.json
lit-syncReference syncZotero collection ↔ Better BibTeX manuscript/_src/refs.bib ↔ Obsidian literature notes. Sole writer of refs.bib (auto-export); upstream of manage-refs
obsidian-paper-vaultVault buildA folder of PDFs → templated Obsidian literature notes + atomic concept notes synthesized across them. Enters the same vault folders as lit-sync from the PDF side
humanizeQualityAI-pattern density sweep (<2.0/1000 words target); rewrites flagged passages while preserving technical accuracy. Phase 7.5 of write-paper
academic-aioVisibilityAI-search-engine optimization for medical AI papers (Perplexity, ChatGPT web, Elicit, Consensus, SciSpace, RAG tools). Opt-in checklist; never auto-applies edits
render-pdf-docDocument layoutNon-bibliography academic markdown → PDF (proposal, briefing, anchor doc, IRB cover, reference table), CJK-aware. Boundary opposite of manage-refs scripts/render_pandoc.sh
fill-protocolForm fillingInstitutional Word form filling (.doc/.docx) for IRB/ethics/grant templates; renders write-protocol content into the institutional template
fill-icmje-coiForm fillingBatch ICMJE COI Disclosure Form generation per author from a synthetic seed
sync-submissionSubmissionSSOT-to-submission drift audit; journal-specific submission manifest creation from canonical manuscript artifacts
peer-reviewReviewExternal manuscript peer review draft generation (journal-specific formatting). Use ONLY for reviewing other authors' work, never for self-review
review-paperWritingScaffold/draft a literature review (narrative / scoping PRISMA-ScR / systematic). Distinct from write-paper (original research) and meta-analysis (pooling)
polish-languageQualityAcademic-English consistency lint + non-native clarity polish (abbreviations, US/UK spelling, ranges, P/p case, units). Style-only; distinct from humanize (AI-tell removal) and check-reporting (guideline items)
author-strategyAnalysisPubMed author-profile analysis: study-type classification, trajectory-archetype, publication-strategy report from a name
batch-cohortAnalysisGenerate N analysis scripts from one validated methodology template × many exposure/outcome combinations (same method, swap variables) + summary matrix
replicate-studyAnalysisReplicate an existing cohort study's methodology on a different database: design extraction, variable-harmonization table, replication-difference report
cross-nationalAnalysisCross-national comparison study (KNHANES + NHANES + CHNS or parallel surveys): variable harmonization + parallel weighted analysis
ma-scoutSystematic reviewMeta-analysis topic discovery + feasibility (professor-first profile→gap, or topic-first question→gap→co-author) before a protocol exists
find-cohort-gapMethodologyResearch-gap discovery from a longitudinal cohort DB: profile strengths, match PI expertise, literature-saturation scan, ranked topic proposals
design-ai-benchmarkingMethodologyDesign/validity review for benchmarking AI systems against a human-expert reference panel (rubrics, calibration probes, panel construction, IRR targets) — before data collection
model-selectionModelingChoose the model for an imaging study: a paper-grounded architecture family (task + modality + data scale + imbalance → shortlist), then vet the concrete repo / checkpoint (licence, version pin, weight provenance; flags an evaluation arm on the benchmark the model was developed or tuned on)
imaging-dataModelingProfile an imaging dataset before any modelling decision (spacing/orientation, intensity domain, label integrity, foreground fraction, target volume) and gate it against the plan; then plan/audit DICOM/NIfTI intake, resampling, normalisation and augmentation with a preprocessing manifest + data-stage leakage gate before model-scaffold
model-scaffoldModelingGenerate a reproducible runnable PyTorch training repo (patient-level seed-locked split, task model, train/eval scripts, repro record) — between choosing an architecture and validating a trained model
radiomics-mlModelingProduce/audit a radiomics / tabular-ML study (imaging or clinical features → penalised logistic / SVM / RF / gradient-boosting / MLP → outcome) with a nested-CV / feature-stability / calibration / external-validation gate (no GPU)
model-assessmentValidationValidate/evaluate a trained imaging model: split-leakage gate + validation design (internal vs external, comparator, sizing); task-correct held-out metrics (Dice + boundary, AUROC + AUPRC with bootstrap CIs, FROC/mAP, calibration, subgroups) → per-case table; uncertainty/OOD/abstention for deployment claims; Grad-CAM/explainability sanity checks + localisation
mllm-evalEvaluationDesign/audit an evaluation harness for an LLM/MLLM clinical task (report generation, VQA, extraction/classification): adjudicated reference, clinical-efficacy metrics beyond BLEU/ROUGE, hallucination, contamination, prompt-sensitivity, reader study
model-cardDocumentationGenerate a Model Card + Datasheet + data-quality pass for an engineer-built imaging model from user-supplied facts, with a completeness gate
contributeSetupOffer a local edit (a journal profile, a fix) back as a pull request or issue without typing git; blocks on patient data in the diff and sends nothing until confirmed. Also files a false positive or a failed step
setup-medsciSetupRead-only runtime diagnostic (Python, R, Node, Claude Code, Git, Zotero, MCP servers): pass/fail table with the setup doc for each missing component

Classification Logic

Classify each request into one of these intents.

Single-skill requests (route directly)

Route to the skill whose Available Skills row matches: name it with a one-line reason, then invoke it. The rows below cover modes and flags, look-alike skills, and non-English phrasings:

User says something like...Route to
"I have a messy folder, help me organize"/intake-project
"Set up a new project" / "Create project scaffold"/manage-project init
"Review my manuscript before submission"/self-review
"Brutally / harshly check before submission" / "top-tier journal final check" / "multi-reviewer / panel review" / "review it from stats, clinical, and imaging angles" / "혹독하게 제출 전 점검"/self-review --panel --json
"Review someone else's manuscript" / "Journal club critique draft" / "외부 논문 리뷰 답변"/peer-review
"Which journal should I submit to?" / "Find a journal" / "I was rejected, where else?"/find-journal
"Sync submission" / "Retarget journal" / "Check SSOT drift"/sync-submission
"Add a journal profile" / "저널 프로필 추가"/add-journal
"Download PDFs" / "Get full texts" / "PDF 다운로드"/fulltext-retrieval
"Visual abstract 만들어줘" / "Graphical abstract" / "GA 생성"/make-figures
"De-identify my data" / "Remove PHI" / "비식별화" / "익명화" / "Anonymize patient data"/deidentify
"Write an IRB protocol" / "Draft ethics submission" / "Research protocol"/write-protocol
"Fill IRB protocol form" / "기관 양식 채워줘" / "심사면제 요청서 채움" / "동의면제 양식"/fill-protocol
"Define my variables" / "Justify cutoff" / "Phenotype definition" / "변수 정의 근거" / "ad-hoc 정의 피하기"/define-variables
"Write a case report" / "I have an interesting case"/write-paper (case-report mode)
"Generate a cover letter" / "Write cover letter for submission"/write-paper (Phase 8+, requires completed manuscript)
"Render manuscript to DOCX" / "Build final .docx" / "Cascade reformat references" / "Apply journal CSL" / "Re-render with Vancouver" / "회람용 docx" / "Zotero CWYW injection"/manage-refs
"Render proposal to PDF" / "Anchor doc PDF" / "한글 학술 PDF" / "Briefing handout PDF" / "IRB cover PDF" / "non-bib markdown → PDF"/render-pdf-doc
"Sync Zotero" / "Refresh refs.bib" / "Better BibTeX export" / "Zotero ↔ Obsidian 동기화" / "literature note 만들어줘"/lit-sync
"PDF를 Obsidian 노트로" / "논문 요약 노트 만들어줘" / "이 폴더의 PDF 정리해줘" / "build a paper vault" / "second brain" / "extract concepts from papers"/obsidian-paper-vault
"ICMJE COI 양식 일괄 생성" / "공저자 COI 폼 만들기" / "Disclosure form batch"/fill-icmje-coi
"AI search optimization" / "Perplexity-friendly abstract" / "RAG visibility" / "GEO checklist" / "Elicit/Consensus 노출"/academic-aio
"Remove AI patterns" / "AI 티 제거" / "humanize this section" / "GPT 흔적 지워줘"/humanize
Multi-skill workflows (plan then execute sequentially)

The Nodes column lists the decision forks to render in interactive mode (Dialogue Protocol below); N1–N11 are defined in ${CLAUDE_SKILL_DIR}/references/dialogue_nodes.md.

ScenarioSkill chainNodes
New project, no prior workintake-project -> search-lit -> design-study -> manage-project initN1, N2 (if user wants manuscript output), N3
Data ready, need a papermanage-project init -> analyze-stats -> make-figures -> write-paperN6 (PHI gate), N3, N4 (journal timing), N2
Draft exists, prepare for submissionself-review -> check-reporting -> verify-refs -> humanize -> academic-aio (opt-in --aio) -> manage-refs (DOCX build + xref QC --strict) -> manage-project checklistN4 (if not yet locked), N8 (only if self-review returns fatal)
Submission rendering & cascade reformatmanage-refs (Workflow A pandoc citeproc, or B Zotero CWYW) -> manage-refs scripts/check_xref.py --strict -> verify-refs -> sync-submission buildN10 (Workflow A vs B selection — see manage-refs SKILL.md decision tree)
Cascade rejection re-targetfind-journal (exclude rejected) -> manage-refs (re-render with new CSL) -> write-paper Phase 8+ (new cover letter) -> sync-submission build --journal {new}N4
Non-bibliography academic deliverable (proposal/briefing/anchor doc)write-protocol -> fill-protocol (institutional form available) ⫶ render-pdf-doc (markdown-only, no form)N11 (form available vs not)
Reference housekeeping cyclelit-sync (Zotero ↔ refs.bib auto-export) -> manage-refs scripts/check_citation_keys.py -> verify-refs --strict (first-author cross-check)—
ICMJE COI batch (multi-author submission)fill-icmje-coi (per-author docx generation from synthetic seed) -> manual circulation—
Medical-AI paper, AI-search visibility passself-review -> humanize -> academic-aio (title, abstract, summary box, README / CITATION.cff / HF card)N4, N9 (section entry for re-edit scope)
Reviewer comments receivedrevise -> analyze-stats (if new analyses needed) -> make-figures (if new figures needed)N1
Meta-analysis from scratchsearch-lit -> fulltext-retrieval -> meta-analysis (handles its own pipeline internally)N2 (MA type), N5 (synthesis scope)
Grant writingsearch-lit -> grant-builderN2 (option 5)
Conference presentationpresent-paper (handles its own pipeline internally)N1
New study, need IRB protocolsearch-lit -> design-study -> calc-sample-size -> define-variables -> write-protocolN3, N2 (option 4 — protocol)
Observational cohort study (retro/screening/registry)intake-project -> design-study -> search-lit -> define-variables -> write-protocol -> analyze-stats -> write-paperN1, N2, N3
Data with PHI, need full pipelinedeidentify -> clean-data -> analyze-stats -> make-figures -> write-paperN6 (mandatory), N3, N4
Data ready, need cleaning firstclean-data -> analyze-stats -> make-figures -> write-paperN6, N3, N4
Full submission chainwrite-paper -> self-review -> check-reporting -> find-journal -> write-paper (Phase 8+ cover letter) -> manage-project checklistN4, N8 (if recovery triggered), N9 (on re-entry)
Post-rejection resubmissionfind-journal (exclude rejected journal) -> write-paper (Phase 8+ new cover letter)N4
Case report pipelinesearch-lit (similar cases) -> write-paper (case-report mode) -> self-review -> check-reporting (CARE) -> find-journalN2 (option 2), N4

Panel mode (/self-review --panel) is opt-in, never automatic. The chains above use single-pass self-review. Add --panel only when the user asks for a high-stakes final pass, because it spawns several reviewer agents plus an editor (several times the tokens); never enable it by default, including in --e2e. Never combine --panel with --fix: a panel diagnoses and prioritizes, and the fix loop is a separate pass.

Ambiguous requests (ask before routing)

If the intent is genuinely unclear, ask ONE clarifying question — never two in one turn. If you can make a reasonable inference, act on it and confirm; inside a pipeline, render the matching node instead of asking. Examples:

  • "Help with my paper" -> Ask: "Do you want to start writing, review an existing draft, or respond to reviewer comments?"
  • "What should I do next?" -> Check for project_state.json or STATUS.md in the working directory first. If found, read it and suggest the next logical step. If not found, ask what they're working on.

Workflow Execution — Dialogue Protocol (interactive default)

Without --e2e, a multi-skill chain runs one decision node per fork. Never replace a node with a plan list and "Shall I proceed?", because that silently commits the paper type, study design, target journal or recovery branch. Also pause at write-paper's built-in gates (outline approval, discussion planning).

Load ${CLAUDE_SKILL_DIR}/references/dialogue_nodes.md the first time the pipeline enters a decision fork in the current session; it holds each node's options, rendering template and autonomous default.

Per-fork execution sequence:

  1. Identify the node for the fork (Nodes column of the Multi-skill workflows table).
  2. Render it with the reference's §"Rendering Template": under ~15 lines, unlocks / locks / recovery_cost per option, autonomous default announced.
  3. Wait for a numeric choice or a control word. One node per turn — never stack two.
  4. Echo the lock in one line before invoking the skill ("Locking: CARE reporting guideline; abstract = structured 250w.").
  5. Invoke the downstream skill for the chosen option, then return to step 1 for the next fork.
  6. Adapt on skill output. If a result invalidates a prior lock (e.g., /self-review surfaces a Step 7.4a trigger), route to the recovery node (N8) instead of continuing the chain.

Control words. back re-enters the previous node. pause halts the pipeline and returns control to the user. skip is allowed only for a node whose locks scope is empty (rare) — otherwise explain why skipping is not available.


Full Pipeline Mode

When the user asks to "run the full pipeline" or similar, run the Standard Pipeline below.

--e2e Flag
Show full SKILL.md (1,601 more words)Show less
Pre-flight Validation (run once at --e2e entry)

Before invoking any downstream skill in --e2e mode, run the following 4 checks. A failure on any one halts the pipeline. Write all four outcomes verbatim to manuscript/<id>/REPORT.md (see §"REPORT.md Generation") under Frozen / Version status + Source artifacts checked.

  1. STATUS / project_state: read STATUS.md or project_state.json in the working directory and confirm the current phase. If neither exists, halt with STATUS_MISSING unless the user passes --no-status.
  2. Frozen artifact: scan manuscript/<id>/v_*_package/. If the latest v_N carries a _FROZEN marker file or INDEX.md::frozen=true, this run is restricted to a v_(N+1)_package/ branch. Any attempt to write directly into v_N halts with FROZEN_VIOLATION.
  3. Required inputs: confirm input artifacts for the requested phase exist. Examples: Phase 4 figure requires analysis/_analysis_outputs.md; Phase 7 self-review requires manuscript/manuscript.md. Missing → halt with REQUIRED_INPUT_MISSING: <path>.
  4. Dependency miss: if the user requested phase k but a prior phase is incomplete, halt with DEPENDENCY_MISS: [Phase i, Phase j] by default. Only when the user explicitly passes --auto-extend may the orchestrator prepend the missing phases and continue.
--e2e Pipeline Behavior

When --e2e is passed (or the user says "end-to-end", "Arm A", or "fully autonomous"):

  1. Set --e2e mode ON.
  2. Pass --autonomous to /write-paper when invoking it.
  3. Pass --json to /self-review and /check-reporting when invoking them.
  4. Skip all orchestrator-level confirmations ("Shall I proceed?") and do NOT render any Dialogue Protocol nodes.
  5. For each node the pipeline would have rendered interactively, apply the node's default (from dialogue_nodes.md) and log the choice to qc/_pipeline_log.md as: [orchestrate] N{id}: defaulted to option {n} ({label}) — {autonomous_rationale}.
  6. DO still respect data-safety gates (PHI Safety Gate / node N6): if PHI status is unknown, HALT the autonomous run with a single prompt. After pre-flight passes, PHI is the only node that can interrupt autonomous mode.
  7. Audit Recovery (node N8): auto-invoke the routed recovery skill. If the route itself fails validation twice, HALT with RECOVERY_HALT_HUMAN_DECISION in the log.
  8. AIO (academic-aio) is OFF by default in --e2e, because AI-search visibility is a pre-submission concern and running it on every autonomous iteration would waste tokens and invite silent rewrites that violate the skill's "never edit silently" contract. Enable it only when the user explicitly adds --aio (or the pipeline is preparing a preprint / GitHub README / HF card alongside submission). When enabled, schedule it after /humanize so the checklist anchors on QC-confirmed and human-readable text, and surface the PASS/PARTIAL/FAIL report to the user — never auto-apply its edits.
  9. After each skill completes, run post-skill validation (see below); once it passes, proceed to the next skill without asking.
Standard Pipeline: Data → Manuscript
  1. /analyze-stats → analysis/tables/*.csv, analysis/figures/*, analysis/_analysis_outputs.md, analysis/analyze.py
  2. /make-figures --study-type {type} → reads analysis/_analysis_outputs.md → analysis/figures/*.pdf, analysis/figures/*.png, analysis/figures/_figure_manifest.md
  3. /write-paper --autonomous (if --e2e) → reads analysis/ → manuscript/manuscript.md (DOCX rendering delegated to step 7)
    • Phase 7.4 internally calls /self-review --json --fix → qc/self_review.md
  4. /check-reporting → reads manuscript/manuscript.md → qc/reporting_checklist.md + qc/reporting_checklist.json (Part D JSON; called within write-paper Phase 7, but orchestrator verifies output)
  5. /verify-refs → reads manuscript/manuscript.md → qc/reference_audit.json (sole output; row-level status in records[])
  6. /self-review --json --fix → reads manuscript/manuscript.md → qc/self_review.md + auto-fix (called within write-paper Phase 7.4, but orchestrator verifies final output)
  7. /manage-refs (Workflow A pandoc citeproc, or B Zotero CWYW) → reads manuscript/manuscript.md + manuscript/_src/refs.bib → manuscript/manuscript_final.docx + qc/xref_audit.json. Submission gate: check_xref.py --strict must pass (no MISSING_DOCX / MISSING_BODY / MISMATCH).
Post-Skill Validation

After each skill completes, verify that expected output files exist, then pass the discovered file paths to the next skill as context. If validation fails, report the error and do NOT proceed to the next skill.

SkillExpected OutputsValidation
/analyze-statsAt least one file in analysis/tables/*.csv OR analysis/_analysis_outputs.mdCheck file existence and non-empty
/make-figuresanalysis/figures/_figure_manifest.md with at least 1 entryParse manifest, verify listed files exist
/write-papermanuscript/manuscript.md (required)Check file existence and non-empty. Do NOT require the DOCX here — manuscript_final.docx is rendered later by /manage-refs (step 7), so requiring it would halt an --e2e run before the DOCX exists
/check-reportingqc/reporting_checklist.md and qc/reporting_checklist.json (Part D JSON)Parse the JSON; halt naming the file if it is absent, unparseable, or lacks an integer missing. If missing > 0 or any action_items[].status == "MISSING", halt with REPORTING_ITEMS_MISSING (list each item) and do NOT proceed to step 7 — route the gaps to /write-paper Phase 7. An inline report that wrote no file does not pass
/verify-refsqc/reference_audit.json (sole output)Parse JSON; halt if submission_safe == false (i.e., FABRICATED / MISMATCH count > 0 OR duplicate_findings[] nonempty)
/self-reviewqc/self_review.md with the Phase 3c JSON block (--json)Parse the JSON block; halt naming the file if it is absent, unparseable, or lacks an integer fatal_count. If fatal_count > 0 or any issues[].severity == "fatal", do NOT proceed to step 7 — route to N8 (Audit Recovery). A REVISE verdict with no fatal issue is logged (score, verdict, counts) in qc/_pipeline_log.md and REPORT.md, not halted. Accept the optional consensus array and R1/R2/R3 attributions that --panel adds to issues (additive, backwards-compatible)
/manage-refsmanuscript/manuscript_final.docx, qc/xref_audit.jsonDOCX exists and non-empty; xref_audit.json has submission_safe: true (no P0 blocker rows)
/lit-syncmanuscript/_src/refs.bib (mtime updated), references/zotero_collection.jsonrefs.bib mtime newer than collection snapshot; refs_bib_refreshed: true in collection JSON

On validation failure:

  • Log the failure: which skill, which output was missing, any error messages.
  • In --e2e mode: report the error in qc/_pipeline_log.md and STOP. Do not proceed to the next skill. Output: "Pipeline halted at {skill}: {missing output}. Check the skill's output and re-run."
  • In interactive mode: report the error and ask the user how to proceed.
REPORT.md Generation

At the termination of every --e2e invocation — whether the pipeline completed, halted at pre-flight, or halted on post-skill validation — the Worker MUST write manuscript/<id>/REPORT.md using the template at ${CLAUDE_SKILL_DIR}/references/report_template.md.

  • Copy every section of the template verbatim. Never delete a section. Empty fields are filled with (none) or (unknown) — never omitted, never collapsed.
  • The §"Pipeline log" entry is a 5-line summary of qc/_pipeline_log.md (Dialogue node defaults applied, skill invocations, halt reason if any) — not a paste of the full log.
  • The §"Tier-3 Blocked Items" hook-vs-prompt-guard split is mandatory — see §"Tier-3 Worker Guard" below.
  • The §"Next safe command" line is the literal command the user can copy to resume the next phase. Do not editorialize.
  • REPORT.md is the single artifact the user reviews; every other QC output is linked from it.
Tier-3 Worker Guard

The following actions are permanently forbidden inside --e2e autonomous flow. On detection, the Worker halts the pipeline and records the attempt under REPORT.md §"Tier-3 Blocked Items" as tier3_pending: <command>. Hook-confirmed blocks and prompt-only blocks are listed separately so a future hook regression cannot silently re-open a prompt-only block.

Hook-confirmed (where a Tier-3 confirm hook is installed):

  • gws gmail +send / +reply
  • YouTube upload

Prompt / skill guard only (no hook coverage — Worker prompt enforces):

  • git push, gh pr create
  • MCP Gmail send, MCP Calendar send
  • MCP GitHub create-pr
  • /sync-submission build external publication paths
  • Phase 8 submission DOCX auto-build / journal submission
  • Senior mentor automatic email reply

git commit is allowed; a subsequent git push attempt halts. Circulation emails are saved as a Gmail Draft only — never sent.

Data Flow Contract

Read ${CLAUDE_SKILL_DIR}/references/data_flow_contract.md when chaining a skill and you need what it reads or writes (the Standard Pipeline above already names its own files).

Post-E2E: Journal Selection & Submission Prep

After the E2E pipeline completes (or when the user requests journal targeting), this workflow is available. It is NOT part of --e2e: it runs only on explicit user invocation, because it needs the user's journal selection.

  1. /find-journal → top 5 recommendations based on manuscript/manuscript.md abstract
  2. /verify-refs → block fabricated or mismatched references before packaging
  3. User selects a journal → create submission/{journal_short}/ directory
  4. /sync-submission build --journal {journal_short} → create or refresh the derived manuscript package from the canonical manuscript
  5. Generate inside submission/{journal_short}/:
    • cover_letter.md: via /write-paper Phase 8+
    • checklist.md: journal-specific submission checklist
    • manuscript_final.docx: re-rendered by /manage-refs for the target journal (if format differs)
  6. /self-review with the selected journal as the target → journal scope-aware final pass (not /peer-review, which reviews other authors' work only)

PHI Safety Gate

Before routing to any data-handling skill (clean-data, analyze-stats, make-figures), check if the data might contain PHI:

  1. For each CSV/Excel file the task will read that is not itself a *_deidentified.* output (a de-identified copy of one file says nothing about the others), ask: "Does the data contain patient identifiers (PHI)? (names, national ID / RRN, date of birth, contact details, etc.)"

    • If yes → Route to /deidentify first, then continue to the originally requested skill using the *_deidentified.* output file
    • If no, or the user confirms the data is already de-identified → Proceed directly
  2. De-identification is an INTERACTIVE process requiring the researcher's active participation. Warn: "De-identification requires the researcher's direct review. You must run the script in the terminal and verify each item."


Context Detection

Before routing, check for context clues in the working directory:

File foundImplies
project_state.jsonActive managed project -- read it to determine current phase
STATUS.mdProject with status tracking -- read current stage and blockers
PROJECT.mdProject identity exists -- use for context
CLAIMS.mdClaims-to-results map exists -- writing is underway
REVIEW_LOG.mdRevision cycle -- likely needs /revise
*.qmd or *.tex filesManuscript drafting in progress
*.bib filesReferences exist -- may need verification
PRISMA_*.md or QUADAS*.mdMeta-analysis or systematic review
Decision letter / reviewer PDFRoute to /revise
CSV/Excel data files without analysis scriptsRaw data may need cleaning -- suggest /clean-data first
*_deidentified.* or audit_log.csvSome data was de-identified -- skip the PHI Safety Gate only for the *_deidentified.* outputs themselves; run it on every other data file the task will read
protocol_draft.mdProtocol drafting in progress -- may need /write-protocol
sample_size_*.csv or sample_size_*.RSample size calculation done -- check if protocol or manuscript next

Guardrails

  • Never invent a skill. Only route to skills listed in the Available Skills table.
  • Respect existing state. If a project scaffold exists, do not re-initialize it.

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

Files

SKILL.md and 6 other files (references) in skills/orchestrate of Aperivue/medsci-skills.

  • SKILL.md
  • references/data_flow_contract.md
  • references/dialogue_nodes.md
  • references/report_template.md
  • references/report_template_ko.md
  • skill.yml
  • tests/test_qc_gate_contract.py

Open the folder on GitHubat commit 3b14ae2

Compare with similar skills

Orchestrate 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.

Orchestrate compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Orchestrate this skillAperivue/medsci-skills329—~8.1kAutomated safety check: PassMIT
Hypothesis Generationspacering-net/codeg3.8k15 repos~3.6kAutomated safety check: NotesMIT
GitHub Deep Researchbytedance/deer-flow83k5 repos~1.3kAutomated safety check: PassMIT
Nature Paper CardYuan1z0825/nature-skills46k2 repos~2.1kAutomated safety check: PassApache-2.0
Read arXiv Paperkarpathy/nanochat58k2 repos~494Automated safety check: PassMIT
Content Research Writerweapp-tailwindcss/weapp-tailwindcss1.9k25 repos~3.5kAutomated safety check: PassMIT

Similar skills

  • Hypothesis Generation

    spacering-net/codeg

    Structured hypothesis formulation from observations. An agent skill from spacering-net/codeg.

    3.8k GitHub starsUsed in 15 repos~3.6k tokens
    Research & ScienceAuto-check: notes
  • GitHub Deep Research

    bytedance/deer-flow

    Researches a GitHub repository over four rounds using the GitHub API and web search, then writes a structured markdown report with timeline, metrics and Mermaid diagrams.

    83k GitHub starsUsed in 5 repos~1.3k tokens
    Research & ScienceAuto-check passed
  • Nature Paper Card

    Yuan1z0825/nature-skills

    Builds a structured deep-reading card for one scientific paper, covering methods, how experiments support claims, limitations and research ideas, with a script to prepare the source.

    46k GitHub starsUsed in 2 repos~2.1k tokens
    Research & ScienceAuto-check passed
  • Read arXiv Paper

    karpathy/nanochat

    Fetches the TeX source of an arXiv paper from its URL, reads it and writes a markdown summary tied to the nanochat project.

    58k GitHub starsUsed in 2 repos~494 tokens
    Research & ScienceAuto-check passed
  • Content Research Writer

    weapp-tailwindcss/weapp-tailwindcss

    Assists in writing high-quality content by conducting research, adding citations, improving hooks, iterating on outlines, and providing real-time feedback on each section.

    1.9k GitHub starsUsed in 25 repos~3.5k tokens
    Research & ScienceAuto-check passed
  • Peer Review

    spacering-net/codeg

    Structured manuscript/grant review with checklist-based evaluation.

    3.8k GitHub starsUsed in 18 repos~5.9k tokens
    Research & ScienceAuto-check: notes

More from Aperivue/medsci-skills

All 54 skills in this repo
  • Model Assessment

    Aperivue/medsci-skills

    A skill your agent uses when validating or evaluating a trained medical-imaging model.

    329 GitHub starsUsed in 1 repo~4.5k tokens
    Auto-check passed
  • Obsidian Paper Vault

    Aperivue/medsci-skills

    A skill your agent uses when turning a folder of research PDFs into Obsidian notes, even if Obsidian is not named.

    329 GitHub stars~1.6k tokensUpdated 3 days ago
    Auto-check passed
  • Radiomics ML

    Aperivue/medsci-skills

    A skill your agent uses when building or auditing a radiomics or tabular clinical-ML prediction model with a classical learner (LASSO, SVM, random forest, XGBoost and similar).

    329 GitHub starsUsed in 1 repo~2.7k tokens
    Auto-check passed
  • Verify Refs

    Aperivue/medsci-skills

    A skill your agent uses when checking whether a manuscript's references are real.

    329 GitHub starsUsed in 1 repo~3.1k tokens
    Auto-check passed
  • Clean Data

    Aperivue/medsci-skills

    A skill your agent uses when a clinical CSV/Excel dataset needs profiling and cleaning before analysis (missing values, outliers, duplicates, type mismatches).

    329 GitHub stars~2k tokensUpdated 3 days ago
    Auto-check passed
  • Design Study

    Aperivue/medsci-skills

    A skill your agent uses when checking a radiology or medical AI study design before drafting or submission.

    329 GitHub stars~3.9k tokensUpdated 3 days ago
    Auto-check passed

Questions about Orchestrate

What does Orchestrate do?

A skill your agent uses when the user describes a research goal without naming a skill, or the task spans several skills. Orchestrate is an agent skill from Aperivue/medsci-skills. Use when the user describes a research goal without naming a skill, or the task spans several skills.

When should I use Orchestrate?

Orchestrate fits situations like: the user describes a research goal without naming a skill; the task spans several skills.

How do I install Orchestrate in Claude Code?

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

How do I install Orchestrate in Codex?

Run `npx skills add Aperivue/medsci-skills --skill orchestrate -a codex`. Or copy the skill folder (skills/orchestrate in Aperivue/medsci-skills) into .agents/skills/orchestrate in your project. Codex loads it when a task matches its description.

Can I use Orchestrate 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 Aperivue/medsci-skills --skill orchestrate -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/orchestrate, .gemini/skills/orchestrate, .github/skills/orchestrate and .opencode/skills/orchestrate in your project.

What does Orchestrate need to run?

Going by SKILL.md and its folder, Orchestrate needs Python for the scripts in its folder and the command-line tools its instructions call (git and gh). Our summary lists: Python 3.

Does Orchestrate access the network?

SKILL.md contains no URLs. Its commands use git and gh, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Orchestrate 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 Orchestrate use?

Orchestrate is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Orchestrate use?

About 8.1k tokens (SKILL.md is roughly 33k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.2k tokens, read only when the agent opens those files.

What are the alternatives to Orchestrate?

Skills that share tags, products or a category with Orchestrate: Hypothesis Generation (spacering-net/codeg, 3.8k stars), GitHub Deep Research (bytedance/deer-flow, 83k stars), Nature Paper Card (Yuan1z0825/nature-skills, 46k stars) and Read arXiv Paper (karpathy/nanochat, 58k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Orchestrate?

Aperivue (a GitHub organization) maintains it in Aperivue/medsci-skills, which has 329 GitHub stars. The repository holds 54 skills in this directory. The repository was last updated on October 5, 2026.

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