No terminal? Use the classroom installer ZIP — download, unzip, double-click the installer, then restart your agent app (see Installation).

Have a terminal? Fastest path — one command, nothing to clone:

npx medsci-skills install        # copies every skill into your agent's folder

Have git? Install every skill in three commands:

git clone https://github.com/Aperivue/medsci-skills.git
mkdir -p ~/.claude/skills
cp -r medsci-skills/skills/* ~/.claude/skills/

Restart Claude Code, then start with /orchestrate — it classifies your request and routes you to the right skill. Full install options (Codex, Cursor, individual skills) are in Installation.

Prefer plugins? One line adds the marketplace; /plugin then lets you browse eight category plugins and enable the ones you want:

/plugin marketplace add Aperivue/medsci-skills
/plugin            # browse eight category plugins; enable the ones you want

Install a single category and invoke its skills under that namespace:

/plugin install medsci-analysis@medsci-skills
/medsci-analysis:analyze-stats

All eight plugins share the same repository source, so this groups and enables skills by category — it is not a partial download. The marketplace tracks main, so a plugin's version is its git commit.

Want just one capability? Two skills are also published as focused standalone repos (generated mirrors; this repo stays the source of truth), each installable on its own with /plugin marketplace add Aperivue/<repo>:

• Aperivue/verify-refs — catch fabricated/mismatched citations (PubMed + CrossRef).
• Aperivue/check-reporting — audit a manuscript against 32 EQUATOR reporting guidelines.

Three public datasets. Three study types. Each produces a complete manuscript, publication-ready figures, and a reporting compliance audit.

from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()  # 569 samples, zero download

Output from orchestrate --e2e (see full demo):

Pipeline: analyze-stats → make-figures → write-paper → AI pattern scan → check-reporting (STARD) → self-review → DOCX build → present-paper

library(metafor)
data(dat.bcg)  # 13 RCTs, 357,347 participants (Colditz et al. 1994)

Output from orchestrate --e2e (see full demo):

Pipeline: analyze-stats (R metafor) → make-figures → write-paper → AI pattern scan → check-reporting (PRISMA 2020) → self-review → DOCX build → present-paper

# Pre-processed NHANES 2017-2018 CSV included
# 5,010 US adults after exclusions

Output from orchestrate --e2e (see full demo):

Pipeline: analyze-stats → make-figures → write-paper → AI pattern scan → check-reporting (STROBE) → self-review → DOCX build → present-paper

Each demo (and real project) follows this role-based folder layout:

project/
├── data/                          # Input data
│   └── raw_data.csv
├── analysis/                      # /analyze-stats + /make-figures outputs
│   ├── tables/
│   ├── figures/
│   │   └── _figure_manifest.md
│   ├── _analysis_outputs.md
│   └── analyze.py
├── manuscript/                    # /write-paper outputs
│   ├── manuscript.md
│   ├── manuscript_final.docx
│   └── title_page.md
├── qc/                            # Quality verification
│   ├── reporting_checklist.md     # /check-reporting
│   ├── self_review.md             # /self-review
│   └── _pipeline_log.md
├── submission/                    # Post-journal-selection (manual trigger)
│   └── {journal_short}/
│       ├── cover_letter.md
│       ├── checklist.md
│       └── peer_review.md
└── presentation/
    └── presentation.pptx

The E2E pipeline (orchestrate --e2e) produces everything up to qc/. The submission/ directory is created after journal selection via /find-journal.

v4.1 ships distribution levers and a submission pre-flight gate — analysis-integrity detectors 24 → 25 (still 43 skills):

• Claude Code plugin marketplace — /plugin marketplace add Aperivue/medsci-skills, then /plugin discovery of eight medsci-* category plugins generated from the catalog SSOT (.claude-plugin/marketplace.json).
• MedSci-Audit detector registry — the deterministic verification layer is now a named, enumerated, citable suite (MEDSCI_AUDIT.md + generated metadata/detectors_catalog.json, six audit families).
• Hero-skill standalone mirrors — scripts/sync_hero_skill.py mirrors a focused skill to its own star-funnel repo; first two live: Aperivue/verify-refs and Aperivue/check-reporting.
• Placeholder/marker gate — check_placeholders.py flags leftover [@NEW:] / [version] / TODO / template-URL markers before submission (the 25th detector).
• Submission pre-flight gate — preflight_gate.py bundles the existing detectors + /verify-refs into one halt-on-failure command (qc/preflight_gate_report.json, non-zero exit on any blocker) — the single last step before freeze.

v4.0 extends the project's own deterministic, no-drift SSOT discipline to the public storefront and finishes the detector backlog — bringing the analysis-integrity detector count in skills/ to 24 (still 43 skills):

• SSOT to the storefront — a generated, machine-readable metadata/skills_catalog.json (slug + research-lifecycle category + one-line description per skill) is now the source the aperivue.com storefront vendors, gated offline so the public site can never silently drift behind the repo (gen_skills_catalog_json.py --check).
• Asset/figure anonymization — /sync-submission scans figure-generating scripts, figure-PDF rendered text, and docx/PDF metadata authors for the institution/author leaks a body-text scan misses (check_asset_anonymization.py).
• Cross-artifact staleness — flags supplement values that disagree with the corrected body, and reporting checklists built against an older manuscript version (check_cross_artifact_stale.py; check_checklist_version.py with a target_manuscript/source_sha256 checklist contract).
• Survival reporting — /analyze-stats emits median survival with its 95% CI, a Cox events-per-variable gate, and cluster-robust SE for nested observation units.

v3.8.0 adds an evaluation/ harness suite that validates the instrument itself — deterministic detector recall on programmatically seeded defects (E1), fresh-clone manifest reproducibility (E4), claim audit-trail completeness (E5), host-portability and metadata-drift checks (E6/E7/E8), and a cost/time table (E3) — each writing a self-describing, reproducible run package. An LLM-comparator (E2) and a self-review convergence harness (E9) ship runnable but are NOT executed in this release. This release also reconciles the README Live-Demos numbers with the v3.7.0 clean-room demo artifacts. Catalog unchanged (still 43 skills, 21 detectors).

v3.7.0 adds three deterministic, stdlib-only detectors on top of the v3.6.0 panel-derived gates — bringing the analysis-integrity detector count in skills/ to 21 — without broadening the catalog (still 43 skills):

• Reference adequacy — /self-review and /write-paper now check that a draft cites enough references in the right sections and that every named method (a competing-risk model, multiple imputation, the E-value, an eGFR equation) carries a citation — the adequacy layer that complements /verify-refs's integrity layer (check_reference_adequacy.py).
• Panel lens-diversity — /self-review --panel post-processes its reviewers so the cost buys breadth, not a louder echo (check_panel_diversity.py).
• Generated-code quality — /analyze-stats lints emitted analysis scripts for reproducibility slop (missing seed, hard-coded data literals, absolute paths, in-place source overwrite) (check_generated_code.py).

Plus a publish-time skill-worthiness gate (/publish-skill) and public adoption/impact tracking (IMPACT.md).

v3.6.0 lands 18 gates from a 13-project panel self-review (158 traces → 12 recurring defect patterns), without broadening the catalog (still 43 skills). Six new stdlib detectors join the existing trio — deterministic where a grep is clean, prose/probe where the call needs a human:

• Cohort & pool arithmetic — /self-review recomputes incidence rates from events ÷ person-years, balances STROBE exclusion cascades, and checks ordinal tier/stratum partitions for disjointness (check_cohort_arithmetic.py); /meta-analysis locks patient/lesion aggregate totals and requires re-run evidence for any "fixed" audit note.
• Claim ↔ artifact ↔ scope — Methods ↔ Results ↔ disk coverage (a run-but-unreported analysis is flagged), an endpoint ↔ conclusion scope gate (a cross-sectional design cannot license a surveillance claim; a binary surrogate is not a care directive), and a reviewer-team 3-way that makes an LLM-as-reviewer fatal.
• Statistical & reporting contracts — a CI/estimand output contract (quantile/proportion/sHR must carry a 95% CI; Cox EPV gate; proportion-MA Egger ban + prediction interval), interval-censoring / PH-violation / CIF-horizon survival rules, reporting-framework base+extension naming, a classical-style body lint, a PROSPERO ID format gate, and a pagination-placeholder citation gate.

Earlier in this series: analysis-integrity guards (confounding completeness, claim-vs-artifact, structural-zero handling), a multi-agent /self-review --panel mode, and shared domain-probe modules vendored byte-identical into /peer-review and /self-review with a CI drift gate.

MedSci-Audit — the verification edge in the first rows above is a named suite of 25 deterministic detectors (citation & reference integrity, cohort & pool arithmetic, scope/estimand contracts, reporting compliance, and more) that catch fabricated or drifted content before a manuscript reaches a reviewer. See MEDSCI_AUDIT.md for the suite, its six families, and its evaluation evidence.

This is not a broad scientific-tooling library — for cheminformatics, structural biology, or genomics pipelines, see K-Dense scientific-agent-skills. It is not a biomedical-skill aggregator — for a broad curated collection, see OpenClaw Medical Skills. For how MedSci Skills compares to these catalogs, see docs/competitive_positioning.md. For verified cross-agent install paths (Claude Code, Codex, Cursor, GitHub Copilot), see docs/host_compatibility.md.

MedSci Skills is opinionated and narrow on purpose: a single physician-researcher's medical-manuscript pipeline, biased toward radiology, diagnostic accuracy, observational EMR studies, and systematic review / meta-analysis. If you write IMRAD manuscripts for clinical journals, audit reporting compliance against EQUATOR guidelines, or run SR/MA workflows end-to-end, this is built for you. For wet-lab protocols, drug discovery, or single-cell genomics, the repos above are better fits.

📖 Per-skill reference: docs/skills/ — one page per skill (what it does, when it activates, its Quality Card — purpose, safety boundaries, known limitations, validation, evidence — and bundled resources), generated from each SKILL.md + skill.yml. See docs/skills/AUDIT.md for how the skills are validated.

                              ┌─────────────────────────────────┐
                              │  orchestrate: single entry point │
                              │  classifies intent, routes to    │
                              │  the right skill or chains them  │
                              └───────────────┬─────────────────┘
                                              │
                  ┌───────────────────────────┼───────────────────────────┐
                  │                           │                           │
            intake-project              (main pipeline)             grant-builder
            (new/messy projects)              │                    (proposals)
                  │                           │
                  ▼                           ▼
                                    ┌── calc-sample-size ──┐
                                    │                      ▼
ma-scout -> search-lit -> fulltext-retrieval -> design-study ──> write-protocol -> manage-project
   │            │
   │            └── find-cohort-gap (DB variables → literature gap → ranked topic proposals)
   │                                    │
   │                                    ▼
   │                         deidentify -> clean-data -> analyze-stats -> make-figures -> write-paper
   │                                                        │                                │
   │                                           replicate-study (paper → new DB)         humanize
   │                                           cross-national (parallel survey)              │
   │                                           batch-cohort (N × M matrix)                   ▼
   │                                                                          find-journal <── self-review
   │                                                                               │                    │
   │                                                                               │                    ▼
   │                                                                               │          humanize -> academic-aio (AI-search visibility)
   │                                                                               ▼
   │                                                    [cover-letter] -> check-reporting -> revise -> present-paper
   │                                                                                                       │
   └── meta-analysis                                                                                  peer-review
                         lit-sync (Zotero + Obsidian sync)     author-strategy (PubMed profile analysis)

                              ┌─────────────────────────────────────────────┐
                              │  publish-skill: package any skill above for │
                              │  open-source distribution (PII audit,       │
                              │  license check, generalization)             │
                              └─────────────────────────────────────────────┘
                              ┌─────────────────────────────────────────────┐
                              │  add-journal: add new journal profiles to   │
                              │  the database (write-paper + find-journal   │
                              │  dual profile generation with quality gates)│
                              └─────────────────────────────────────────────┘

No terminal? Use the classroom installer ZIP. Download, unzip, double-click the installer, then restart your desktop agent app.

Windows:

https://github.com/Aperivue/medsci-skills/releases/latest/download/medsci-skills-classroom-windows.zip

macOS:

https://github.com/Aperivue/medsci-skills/releases/latest/download/medsci-skills-classroom-macos.zip

After unzipping:

• Windows: double-click installers/install-windows.cmd
• macOS: double-click installers/install-macos.command

Then restart Claude Code Desktop, Codex Desktop, or Cursor and test with:

MedSci Skills가 설치됐는지 확인하고, 오늘 실습에 쓸 대표 스킬 5개만 보여줘.

git clone https://github.com/Aperivue/medsci-skills.git
cp -r medsci-skills/skills/* ~/.claude/skills/

git clone https://github.com/Aperivue/medsci-skills.git
cp -r medsci-skills/skills/check-reporting ~/.claude/skills/

A convenience wrapper for terminal users — it copies the same skills via the dependency-free Python installer. The canonical install paths remain the plugin marketplace (Option 1's sibling above) and the git clone above; npm is just a shortcut.

npx medsci-skills install            # all hosts (Claude, Codex, Cursor)
npx medsci-skills install --target claude
npx medsci-skills list               # list bundled skills
npx medsci-skills doctor             # quick Node/Python/skill-folder check

Requires Node 18+ and (for install/doctor) python3 on your PATH.

• Claude Code: skills are copied to ~/.claude/skills/ (also read by GitHub Copilot and Cursor).
• Codex: skills are copied to ~/.agents/skills/ (also read by Cursor and GitHub Copilot).
• Cursor: no separate step needed — Cursor reads ~/.claude/skills/ and ~/.agents/skills/ directly. The installer can still write an optional .cursor/rules/ steering rule with --cursor-project.
• See docs/host_compatibility.md for the verified per-host install paths and their official sources.
• Windows users do not need WSL for the basic classroom workflow. Use WSL only for advanced reproducible Linux toolchains.

See docs/classroom_distribution_plan.md and docs/classroom_materials.md for instructor distribution, email templates, and first-class exercises.

Tip: Not sure which skill to use? Start with /orchestrate -- it will classify your request and route you to the right tool.

orchestrate --e2e or write-paper --autonomous runs the full pipeline from data to submission-ready DOCX with bounded validation. Skills pass outputs via structured manifests (_analysis_outputs.md, _figure_manifest.md) and project artifacts (project.yaml, artifact_manifest.json, qc/status.json). If a skill fails to produce expected outputs, the pipeline halts rather than proceeding with missing data. Phase 7 enforces a strict QC chain: AI pattern removal → reporting compliance check → /verify-refs citation audit → numerical claim audit → self-review with auto-fix (max 2 iterations) → DOCX/submission build.

Every reference produced by search-lit is verified against PubMed, Semantic Scholar, or CrossRef APIs. Existing manuscripts should then run /verify-refs, which writes a visible reference audit and blocks fabricated references before submission. No citation is ever generated from memory alone. API errors are batched silently -- no token waste from repeated failure messages.

/meta-analysis Phase 6b, /self-review Phase 2.5a, /revise Step 2.5, and /write-paper Step 7.3a enforce a common 3-layer audit (CSV ↔ analysis script ↔ manuscript) with primary- source back-checking for pooled estimates and revision-era numbers. Hand-typed numerical matrices without CSV-coordinate comments are flagged as structural risks even when the values are currently correct, since the next revision will re-introduce the same failure mode.

Projects declare their source-of-truth layout in SSOT.yaml, and a qc/migration_complete marker gates strict enforcement. /verify-refs is the sole writer of qc/reference_audit.json. The MEDSCI_VERIFY_REFS_MODE env var (auto default, warn, enforce, off) controls behavior — auto blocks only when both SSOT.yaml and the migration marker are present, otherwise warns. Legacy projects freeze as warn-only; new projects opt in via scripts/migrate_project_to_ssot.py. An optional PostToolUse hook (not shipped in this repo — document only) can invoke /verify-refs automatically on manuscript saves for users who install it locally at ~/.claude/hooks/verify-refs-guard.sh; the regression suite (tests/test_phase1c_hooks.sh) runs end-to-end only when that local hook is present and is skipped otherwise.

/meta-analysis ships empirical failure-mode references (data integrity, review orchestration, submission package drift, post-submission release ops) with four automation hooks: scripts/prisma_5way_consistency.py (DI-6 PRISMA number consistency), scripts/extraction_consensus_log_init.py (DI-1 dual-extraction scaffold), scripts/tag_cleanup_gate.sh (DI-8 placeholder tag gate), and scripts/verify_package_integrity.py (SPD SHA-256 manifest for submission bundles).

check-reporting includes bundled checklists for 32 guidelines and risk-of-bias tools: STROBE, STARD, STARD-AI, TRIPOD, TRIPOD+AI, PRISMA 2020, PRISMA-DTA, PRISMA-P, MOOSE, ARRIVE, CONSORT, CARE, SPIRIT, CLAIM, SQUIRE 2.0, CLEAR, GRRAS, MI-CLEAR-LLM, SWiM, AMSTAR 2, QUADAS-2, QUADAS-C, RoB 2, ROBINS-I, ROBINS-E, ROBIS, ROB-ME, PROBAST, PROBAST+AI, NOS, COSMIN, RoB NMA. Includes Results/Discussion section boundary checks and machine-readable JSON summary for pipeline integration.

analyze-stats generates reproducible Python/R code for 13 analysis types -- including regression, propensity score, and repeated measures -- with mandatory calibration for prediction models. make-figures produces journal-specification figures (300 DPI, colorblind-safe palettes, proper dimensions), visual/graphical abstracts, and a tool selection guide (D2 for flow diagrams, matplotlib for data plots). --study-type auto-generates the complete figure set for each study design.

write-paper enforces strict separation: Results contain only factual findings (no interpretation, no "why"), Discussion uses interactive anchor-paper scaffolding. The critic rubric includes a dedicated Section Boundaries pass/fail gate.

design-study -> calc-sample-size -> write-protocol gives you an IRB-ready protocol. After data collection: clean-data -> analyze-stats -> write-paper -> self-review -> find-journal -> cover letter. Every transition is a defined skill handoff.

Skills call each other. check-reporting invokes make-figures for PRISMA diagrams. write-paper calls search-lit for citation verification. self-review delegates reporting compliance to check-reporting. calc-sample-size output feeds directly into write-protocol's IRB justification section.

New to Python, R, or the command line? The full step-by-step guide for clinicians is in docs/setup/:

• Mac setup — Homebrew → Python 3.11 → R → Node → Claude Code (~30 min)
• Windows setup — winget-based, no WSL required
• MCP server setup — Zotero, Google Drive, PubMed integration
• Common issues — top 10 fixes (PATH, Apple Silicon, antivirus, JSON syntax)

Verify your environment with the diagnostic skill (read-only, installs nothing):

/setup-medsci

Prints a checklist showing which components are present, which are missing, and which doc to follow for any gap.

• An Agent Skills-compatible host — Claude Code (primary), or Codex / Cursor / GitHub Copilot (see docs/host_compatibility.md; some live-data workflows rely on Claude MCP servers)
• Python 3.9+ (for statistical analysis and figure generation)
• R 4.0+ with meta (>=7.0), metafor (>=4.0), mada (>=0.5.11) packages (for meta-analysis)

"I have data and want a complete manuscript with zero manual steps."

/orchestrate --e2e      # Autonomous: analyze → figures → write → QC → DOCX

Or equivalently: /write-paper --autonomous if analysis and figures already exist.

"I have a diagnostic accuracy study draft and need to check compliance."

/design-study          # Review study design for leakage and bias
/analyze-stats         # Generate DTA statistics (sensitivity, specificity, AUC with CIs)
/make-figures          # Create ROC curve + STARD flow diagram
/check-reporting       # Audit against STARD checklist

"I'm starting a meta-analysis and need to find relevant studies."

/search-lit            # Systematic search across PubMed + Semantic Scholar
/fulltext-retrieval    # Batch download open-access PDFs for included studies
/meta-analysis         # Full DTA or intervention MA pipeline
/make-figures          # Forest plot + PRISMA flow diagram
/check-reporting       # Audit against PRISMA-DTA checklist

"I need to present a paper at journal club."

/present-paper         # Analyze paper, find supporting refs, draft speaker script

"I need to submit an IRB protocol for a new study."

/search-lit            # Background literature for rationale
/design-study          # Validate study design, identify bias risks
/calc-sample-size      # Power analysis with IRB justification text
/write-protocol        # Generate 4 core sections + 6 skeleton sections

"I have an interesting case to publish."

/write-paper           # Case report mode (CARE 2016, 1000-word short-form)
/self-review           # Pre-submission self-check
/find-journal          # Which journal accepts case reports in this field?

"My paper was rejected. Where else should I submit?"

/find-journal          # Exclude rejected journal, recommend alternatives
/write-paper           # Generate new cover letter (Phase 8+)

"I have messy clinical data that needs cleaning before analysis."

/deidentify            # Remove PHI from clinical data (standalone Python, no LLM)
/clean-data            # Profile dataset, flag issues, generate cleaning code
/analyze-stats         # Run statistics on cleaned data
/make-figures          # Publication-ready figures

"I want to write a grant proposal for a radiology AI project."

/design-study          # Validate study design before writing
/grant-builder         # Structure significance, innovation, approach
/search-lit            # Find supporting literature with verified citations

Adoption is tracked openly in IMPACT.md (stars, forks, traffic, release downloads — snapshotted weekly into metrics/traffic_log.csv) and academic use is logged in docs/citations.md.

Used MedSci Skills in your research? Please let us know. It helps other researchers find the toolkit — and we list it (with your permission).

These skills are research productivity tools. They do not provide clinical decision support, medical advice, or diagnostic recommendations. All outputs should be reviewed by qualified researchers before use in any publication or clinical context.

• make-figures Critic Loop is inspired by PaperBanana (Zhu et al., Automating Academic Illustration for AI Scientists, arXiv:2601.23265, 2025) and by prior self-refinement research — Self-Refine (Madaan et al., 2023), Reflexion (Shinn et al., 2023), and Constitutional AI (Anthropic, 2022). The implementation in this repository is a clean-room reconstruction specialized for medical publication figures; no code, prompts, or configurations are derived from PaperBanana's repository.
• Reporting-guideline checklists bundled with check-reporting are redistributed under their original Creative Commons licenses (see each checklist for attribution).
• Wong colorblind-safe palette: Wong B. Points of view: Color blindness. Nature Methods 8:441 (2011).

MIT License. See LICENSE for details.

Bundled reporting guideline checklists retain their original Creative Commons licenses. See each checklist file for attribution.

Optional dependency: pdf_to_md.py uses pymupdf4llm (AGPL-3.0). Not bundled -- installed separately by the user via pip install pymupdf4llm.

Built by Aperivue -- tools for medical AI research and education.

If you find this useful, consider giving it a star. It helps other researchers discover these tools.