Agent skill

Sdtm Oak

by RConsortium in RConsortium/pharma-skills

Derives CDISC SDTM domains from raw clinical (EDC/eCRF) data using the {sdtm.oak} R package.

MITAuto-check passed

Install Sdtm Oak

skills CLI
$ npx skills add RConsortium/pharma-skills --skill sdtm-oak -a claude-code

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

GitHub CLI
$ gh skill install RConsortium/pharma-skills sdtm-oak --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/RConsortium/pharma-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/sdtm-oak .claude/skills/sdtm-oak && 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
sdtm-oak
GitHub stars
119
Token cost
~3.9k tokens
SKILL.md length
929 words
Files
4 (incl. references)
Skills in repo
13
Repo updated
First seen
Licence
MIT

At a glance

Derives CDISC SDTM domains from raw clinical (EDC/eCRF) data using the {sdtm.oak} R package.

  • Works in 12 steps: Setup and data inspection → Generate oak ID variables → Load controlled terminology → …
  • A user needs to map raw study data to SDTM Events (AE
  • SKILL.md covers Inputs, Core algorithms, Workflow and Findings domains (VS, LB, EG), plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Sdtm Oak is an agent skill from RConsortium/pharma-skills. Derives CDISC SDTM domains from raw clinical (EDC/eCRF) data using the {sdtm.oak} R package. Use when a user needs to map raw study data to SDTM Events (AE, CM, MH), Findings (VS, LB, EG), or Interventions (EX) domains following the sdtm.oak algorithm framework. Produces executable, submission- ready R code with controlled terminology recoding, ISO 8601 date derivation, sequence numbering, and study day calculation.

Its SKILL.md is about 3.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `README.md` and `references/oak-functions.md`). Compatibility notes: Requires R with sdtm.oak (= 0.2.0), dplyr, and tibble installed. Requires raw EDC/eCRF data and a controlled terminology (CT) specification CSV. Designed for…

The repository describes itself as: A collection of agent skills for BioPharma use cases GSDBench Intake https://rconsortium.github.io/pharma-skills/gsdbench-intake/. The licence is MIT.

When your agent uses it

  • A user needs to map raw study data to SDTM Events (AE
  • Interventions (EX) domains following the sdtm.oak algorithm framework

Example prompts

  • “Use the sdtm-oak skill to derive CDISC SDTM domains from raw clinical (EDC/eCRF) data using the {sdtm.oak} R package”
  • “/sdtm-oak”

Requirements

  • Compatibility (from SKILL.md): Requires R with sdtm.oak (>= 0.2.0), dplyr, and tibble installed. Requires raw EDC/eCRF data and a controlled terminology (CT) specification CSV. Designed for use in a GxP-compliant environment.

Workflow steps

12 steps, taken from the step headings in SKILL.md.

  1. Setup and data inspection
  2. Generate oak ID variables
  3. Load controlled terminology
  4. Hardcode domain constants
  5. Assign free-text variables (assign_no_ct)
  6. Assign CT-mapped variables (assign_ct)
  7. Assign datetime variables (assign_datetime)
  8. Conditional derivations (condition_add)
  9. Add STUDYID and USUBJID
  10. Study day derivation
  11. Sequence number
  12. Supplemental domain (SUPP--)

What it can do on your machine

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

    No scripts in the folder and no shell commands in SKILL.md (its code samples are r).

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

  • Network

    No URLs in SKILL.md.

    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.

  • Compatibility

    Requires R with sdtm.oak (>= 0.2.0), dplyr, and tibble installed. Requires raw EDC/eCRF data and a controlled terminology (CT) specification CSV. Designed for use in a GxP-compliant environment.

    From compatibility in the SKILL.md frontmatter.

Context cost

Sdtm Oak loads about 3.9k tokens when it runs, and up to ~5.3k if it reads all its reference files. Until then it costs about 107 tokens; SKILL.md has 929 words of instructions outside code blocks.

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

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 RConsortium/pharma-skills at commit ae5d83b, republished under its MIT licence (© RConsortium). 929 words, ~3,915 tokens.

Download SKILL.mdSave it as .claude/skills/sdtm-oak/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
sdtm-oak
description
Derives CDISC SDTM domains from raw clinical (EDC/eCRF) data using the {sdtm.oak} R package. Use when a user needs to map raw study data to SDTM Events (AE, CM, MH), Findings (VS, LB, EG), or Interventions (EX) domains following the sdtm.oak algorithm framework. Produces executable, submission- ready R code with controlled terminology recoding, ISO 8601 date derivation, sequence numbering, and study day calculation.
compatibility
Requires R with sdtm.oak (>= 0.2.0), dplyr, and tibble installed. Requires raw EDC/eCRF data and a controlled terminology (CT) specification CSV. Designed for use in a GxP-compliant environment.
license
MIT
metadata.author
pharma-skills contributors
metadata.version
0.1
metadata.pharmaverse
true

sdtm-oak

Derives CDISC SDTM domains from raw clinical data using the {sdtm.oak} algorithm framework. Outputs executable R code with full derivation traceability.

See references/oak-functions.md for the full function reference.


Inputs

Before generating code, confirm:

InputRequiredNotes
Raw EDC datasetYese.g. ae_raw, vs_raw — raw CRF form data
CT specificationYesCSV in CDISC codelist format; load via read_ct_spec()
Domain specificationYesVariable list, CT codelists per variable, date formats
DM domainFor study day / BLFLProvides RFSTDTC for derive_study_day() and derive_blfl()

Always inspect the raw dataset first — raw column names vary by EDC system and study. Print names(raw_dat) and head(raw_dat) before writing any derivations.


Core algorithms

sdtm.oak provides six mapping algorithms. Choose based on whether the target variable has controlled terminology (CT) and whether the value is derived from raw data or hardcoded.

AlgorithmCT?SourceUse for
assign_no_ct()NoRaw columnFree-text variables: AETERM, CMTRT, VSORRES
assign_ct()YesRaw columnCT-mapped from raw: AESEV, AESER, SEX, RACE
hardcode_no_ct()NoFixed valueStudy-constant free-text: STUDYID, custom flags
hardcode_ct()YesFixed valueDomain constants validated against CT: DOMAIN
assign_datetime()—Raw date col(s)Any --DTC variable: AESTDTC, VSDTC, EXSTDTC
condition_add()—Condition exprGate any of the above to a row subset

All six functions share the same id_vars join key (default: oak_id_vars()) and the same tgt_dat pipe pattern — pass the growing SDTM dataset as tgt_dat to accumulate variables.


Workflow

Follow these steps in order. Write code section by section, not as a single block.

Step 1 — Setup and data inspection
r
library(sdtm.oak)
library(dplyr)

# Load raw data — replace with actual source
ae_raw <- <load raw AE data>   # e.g. sdtm.oak::ae_raw for the package example

# ALWAYS inspect before writing derivations
cat("Columns:\n"); print(names(ae_raw))
cat("Rows:", nrow(ae_raw), "\n")
print(head(ae_raw, 3))
Step 2 — Generate oak ID variables

generate_oak_id_vars() adds three key columns used as join keys throughout all subsequent derivations. Call this once on the raw dataset.

r
# REVIEW: Set pat_var to the column holding the subject/patient identifier
#   in this raw dataset. Set raw_src to the raw dataset object name (e.g. "ae_raw",
#   "vs_raw") — pharmaverse convention uses the dataset name, not a CRF form label.
ae_oak <- generate_oak_id_vars(
  raw_dat = ae_raw,
  pat_var = "patient_number",   # confirm column name from Step 1 inspection
  raw_src = "ae_raw"            # pharmaverse convention: use the raw dataset name
)
# Adds: oak_id (row key), raw_source (form label), patient_number (subj ID)
Step 3 — Load controlled terminology
r
# REVIEW: Replace path with the study CT spec CSV.
#   For the sdtm.oak package example data, use read_ct_spec_example().
ct_spec <- read_ct_spec_example()   # or: read_ct_spec("path/to/ct_spec.csv")

# Validate before use
assert_ct_spec(ct_spec)
Step 4 — Hardcode domain constants

Fixed values that apply to every record in the domain. Use hardcode_ct() for values validated against CT (DOMAIN); use hardcode_no_ct() for free-text constants.

r
ae_domain <- ae_oak |>
  # DOMAIN is a CT-controlled variable — use hardcode_ct
  hardcode_ct(
    tgt_var  = "DOMAIN",
    tgt_val  = "AE",
    raw_dat  = ae_raw,
    raw_var  = "AETERM",   # presence filter: only rows with a non-NA AE term
    ct_spec  = ct_spec,
    ct_clst  = "DOMAIN"
  )
Step 5 — Assign free-text variables (assign_no_ct)

Use for variables with no CT restriction — raw text carried directly.

r
ae_domain <- ae_domain |>
  assign_no_ct(
    tgt_var = "AETERM",
    raw_dat = ae_raw,
    raw_var = "ae_term"   # REVIEW: confirm raw column name
  ) |>
  assign_no_ct(
    tgt_var = "AELOC",
    raw_dat = ae_raw,
    raw_var = "ae_location"
  )
Step 6 — Assign CT-mapped variables (assign_ct)

Use for variables whose values must be recoded to CDISC controlled terminology. Supply ct_clst matching the codelist name in your CT spec.

r
# REVIEW: Confirm ct_clst names match the codelist_code column in ct_spec.
#   Wrong ct_clst silently returns the uppercased raw value — verify outputs.
ae_domain <- ae_domain |>
  assign_ct(
    tgt_var = "AESEV",
    raw_dat = ae_raw,
    raw_var = "severity",
    ct_spec = ct_spec,
    ct_clst = "AESEV"
  ) |>
  assign_ct(
    tgt_var  = "AESER",
    raw_dat  = ae_raw,
    raw_var  = "serious_ae",
    ct_spec  = ct_spec,
    ct_clst  = "NY"
  ) |>
  assign_ct(
    tgt_var  = "AEREL",
    raw_dat  = ae_raw,
    raw_var  = "causality",
    ct_spec  = ct_spec,
    ct_clst  = "AEREL"
  ) |>
  assign_ct(
    tgt_var  = "AEOUT",
    raw_dat  = ae_raw,
    raw_var  = "outcome",
    ct_spec  = ct_spec,
    ct_clst  = "AEOUT"
  )
Step 7 — Assign datetime variables (assign_datetime)

Use for all --DTC variables. Never use as.Date(), as.POSIXct(), or string manipulation for SDTM dates — always use assign_datetime().

r
# REVIEW: raw_fmt must exactly match the date format in the raw data.
#   Use "y-m-d" for ISO (2024-03-15), "d/m/y" for European (15/03/2024),
#   "m/d/y" for US (03/15/2024). Check format from Step 1 inspection.
#   Supply a list of alternatives if the format is inconsistent across records.
ae_domain <- ae_domain |>
  assign_datetime(
    tgt_var = "AESTDTC",
    raw_dat = ae_raw,
    raw_var = "onset_date",
    raw_fmt = "d-m-y"      # REVIEW: confirm raw date format
  ) |>
  assign_datetime(
    tgt_var = "AEENDTC",
    raw_dat = ae_raw,
    raw_var = "resolution_date",
    raw_fmt = "d-m-y"      # REVIEW: confirm raw date format
  )

For combined date-time (e.g. separate date and time columns):

r
ae_domain <- ae_domain |>
  assign_datetime(
    tgt_var = "AESTDTC",
    raw_dat = ae_raw,
    raw_var = c("onset_date", "onset_time"),   # two columns
    raw_fmt = c("d-m-y", "H:M")               # one format per column
  )
Step 8 — Conditional derivations (condition_add)

Use condition_add() to restrict a derivation to a subset of records. Wrap the target dataset in condition_add(), then pass it as tgt_dat.

r
# REVIEW: condition_add() criteria must reflect the study protocol.
#   Document the business rule the condition implements.
ae_domain <- ae_domain |>
  # Example: derive AEDTHFL only for fatal outcome records
  (\(dat) assign_ct(
    tgt_dat = condition_add(dat, AEOUT == "FATAL"),
    tgt_var = "AEDTHFL",
    raw_dat = ae_raw,
    raw_var = "death_flag",
    ct_spec = ct_spec,
    ct_clst = "NY"
  ))()
Step 9 — Add STUDYID and USUBJID

Derive subject-level identifiers after domain variables are built.

r
ae_domain <- ae_domain |>
  hardcode_no_ct(
    tgt_var = "STUDYID",
    tgt_val = "CDISCPILOT01",   # REVIEW: replace with actual study ID
    raw_dat = ae_raw,
    raw_var = "patient_number"
  ) |>
  assign_no_ct(
    tgt_var = "USUBJID",
    raw_dat = ae_raw,
    raw_var = "patient_number"   # REVIEW: confirm USUBJID construction rule
  )
Step 10 — Study day derivation

Requires DM domain (provides RFSTDTC).

r
# REVIEW: Confirm which DTC variable is the reference date for this domain
#   (RFSTDTC for most event domains; RFXSTDTC for findings relative to dosing).
ae_domain <- derive_study_day(
  sdtm_in      = ae_domain,
  dm_domain    = dm,
  tgdt         = "AESTDTC",
  refdt        = "RFSTDTC",
  study_day_var = "AESTDY"
) |>
  derive_study_day(
    sdtm_in      = _,
    dm_domain    = dm,
    tgdt         = "AEENDTC",
    refdt        = "RFSTDTC",
    study_day_var = "AEENDY"
  )
Step 11 — Sequence number
r
ae_domain <- derive_seq(
  sdtm_in = ae_domain,
  tgt_var = "AESEQ"
)
Step 12 — Supplemental domain (SUPP--)

If the study collects non-standard variables, split them to SUPPAE.

r
# REVIEW: Confirm which variables belong in SUPPAE vs the main domain.
#   Non-standard variables must not appear in the parent domain.
result <- generate_sdtm_supp(
  sdtm_dataset  = ae_domain,
  idvar         = "AESEQ",
  supp_qual_info = supp_spec,    # dataframe: QNAM, QLABEL, QORIG per variable
  qnam_var      = "QNAM",
  label_var     = "QLABEL",
  orig_var      = "QORIG"
)
ae_final   <- result$sdtm
suppae     <- result$supp
Step 13 — Final checks
r
# Required SDTM variables for AE domain
required_vars <- c("STUDYID", "DOMAIN", "USUBJID", "AESEQ",
                   "AETERM", "AESTDTC")
missing_vars <- setdiff(required_vars, names(ae_final))
if (length(missing_vars) > 0) {
  stop("Missing required AE variables: ", paste(missing_vars, collapse = ", "))
}

# No duplicate sequence numbers
stopifnot(
  ae_final |>
    count(STUDYID, USUBJID, AESEQ) |>
    filter(n > 1) |>
    nrow() == 0
)

cat("AE domain: ", nrow(ae_final), "records,",
    n_distinct(ae_final$USUBJID), "subjects\n")

Findings domains (VS, LB, EG)

Findings domains (one record per subject per test per visit) follow a different stacking pattern — derive each TESTCD separately, then bind_rows().

r
# REVIEW: Each parameter block must align with the CT codelist for VSTESTCD.
#   Stack only parameters in scope for this study per the CRF and SAP.

# Parameter 1: Systolic Blood Pressure
sysbp <- generate_oak_id_vars(vs_raw, pat_var = "patient_number",
                               raw_src = "vs_raw") |>
  hardcode_ct(tgt_var = "VSTESTCD", tgt_val = "SYSBP",
              raw_dat  = vs_raw, raw_var = "SYSBP_result",
              ct_spec  = ct_spec, ct_clst = "VSTESTCD") |>
  hardcode_no_ct(tgt_var = "VSTEST", tgt_val = "Systolic Blood Pressure",
                 raw_dat = vs_raw, raw_var = "SYSBP_result") |>
  assign_no_ct(tgt_var = "VSORRES", raw_dat = vs_raw, raw_var = "SYSBP_result") |>
  assign_no_ct(tgt_var = "VSORRESU", raw_dat = vs_raw, raw_var = "SYSBP_unit") |>
  assign_datetime(tgt_var = "VSDTC", raw_dat = vs_raw,
                  raw_var = "visit_date", raw_fmt = "d-m-y")

# Parameter 2: Diastolic Blood Pressure — same pattern, different raw_var
diabp <- generate_oak_id_vars(vs_raw, pat_var = "patient_number",
                               raw_src = "vs_raw") |>
  hardcode_ct(tgt_var = "VSTESTCD", tgt_val = "DIABP", ...) |>
  ...

# Stack all parameters
vs_domain <- bind_rows(sysbp, diabp, pulse, weight, height, temp) |>
  hardcode_ct(tgt_var = "DOMAIN", tgt_val = "VS",
              raw_dat = vs_raw, raw_var = "patient_number",
              ct_spec = ct_spec, ct_clst = "DOMAIN") |>
  derive_seq(tgt_var = "VSSEQ")

For findings, also derive VSBLFL (baseline flag) when applicable:

r
# REVIEW: Confirm baseline visit name(s) from the protocol.
vs_domain <- derive_blfl(
  sdtm_in          = vs_domain,
  dm_domain        = dm,
  tgt_var          = "VSBLFL",
  ref_var          = "VSDTC",
  baseline_visits  = c("BASELINE", "DAY 1")   # REVIEW: protocol-specific
)

# REVIEW: annotation rules

Place a # REVIEW: comment whenever a derivation contains a protocol-specific decision that a QC reviewer must verify. Required locations:

LocationWhat to annotate
generate_oak_id_vars()pat_var column name; raw_src must be the raw dataset name (e.g. "ae_raw")
Every assign_datetime()raw_fmt format string — must match actual raw data
Every assign_ct()ct_clst codelist name — wrong codelist silently miscodes
Every condition_add()The business rule the condition implements
derive_blfl() baseline_visitsProtocol baseline visit definition
derive_study_day() refdtReference date choice (RFSTDTC vs RFXSTDTC)
Any hardcoded tgt_valConfirm value is correct for this study

Show full SKILL.md (344 more words)Show less

Common errors to avoid

  • Using as.Date(), substr(), or format() on raw date columns instead of assign_datetime() — ISO 8601 partial date handling and unknown-date placeholders ("UN", "UNK") are only correctly handled by assign_datetime()
  • Skipping generate_oak_id_vars() — all assign_* and hardcode_* functions require oak_id, raw_source, and patient_number columns to be present as join keys; the dataset will silently return wrong results without them
  • Passing the wrong raw_dat to an assign_* call — raw_dat must always be the original raw dataset, not the growing tgt_dat; mixing them causes incorrect joins
  • Using mutate() or rename() for variable mapping instead of assign_no_ct() — mutate bypasses the oak traceability framework and does not respect id_vars join semantics
  • Using assign_no_ct() for CT-mapped variables — values will not be recoded to CDISC terminology; use assign_ct() whenever a codelist applies
  • Using assign_ct() with the wrong ct_clst — no error is raised; unmatched values are silently uppercased; always verify output distribution after derivation
  • Skipping assert_ct_spec() before first use — malformed CT specs produce silent miscoding
  • Not calling derive_seq() — --SEQ is required for all SDTM domains; do not derive it manually with row_number()
  • Mixing up hardcode_ct() vs hardcode_no_ct() for DOMAIN — DOMAIN must use hardcode_ct() (validated against the DOMAIN codelist); using hardcode_no_ct() will accept any string
  • For findings domains: building the full stacked dataset with bind_rows() before adding common variables (DOMAIN, USUBJID, study day) — add per-test variables in each parameter block, then add common variables after stacking

Output checklist

Before returning code, verify:

  • Raw dataset inspected (names() + head()) before first derivation
  • generate_oak_id_vars() called first with correct pat_var and raw_src
  • CT spec loaded and validated with assert_ct_spec()
  • DOMAIN hardcoded with hardcode_ct() — not hardcode_no_ct()
  • All --DTC variables derived with assign_datetime() — not as.Date()
  • Every assign_datetime() has a # REVIEW: on raw_fmt
  • Every assign_ct() has a # REVIEW: on ct_clst
  • Every condition_add() has a # REVIEW: on the business rule
  • raw_dat in each assign_* call is the original raw dataset
  • derive_seq() called to generate --SEQ
  • derive_study_day() called for event/finding date study days (requires DM)
  • Required domain variables present (stopifnot() or stop() guard)
  • No duplicate --SEQ values (stopifnot() check)
  • Findings domains: per-test blocks stacked with bind_rows() before adding common variables

© RConsortium, 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 3 other files (references) in sdtm-oak of RConsortium/pharma-skills.

  • SKILL.md
  • LICENSE
  • README.md
  • references/oak-functions.md

Open the folder on GitHubat commit ae5d83b

Compare with similar skills

Sdtm Oak 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.

Sdtm Oak compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Sdtm Oak this skillRConsortium/pharma-skills119—~3.9kAutomated safety check: PassMIT
Bio Clinical Biostatistics Cdisc DataGPTomics/bioSkills1.2k2 repos~7.3kAutomated safety check: PassMIT
Clinical Reportsdavila7/claude-code-templates32k11 repos~9.9kAutomated safety check: NotesMIT
Clinical Researchalirezarezvani/claude-skills28k—~2.7kAutomated safety check: PassMIT
Clinical Decision SupportK-Dense-AI/scientific-agent-skills48k1 repos~3.5kAutomated safety check: PassMIT
Radiology Clinical Domainhuang-sir1/radiology-skills1.9k—~2.9kAutomated safety check: PassCustom licence

Similar skills

  • Reads, validates, and prepares CDISC SDTM and ADaM clinical trial data for analysis.

    1.2k GitHub starsUsed in 2 repos~7.3k tokens
    Research & ScienceAuto-check passed
  • Clinical Reports

    davila7/claude-code-templates

    Write comprehensive clinical reports including case reports (CARE guidelines), diagnostic reports (radiology/pathology/lab), clinical trial reports (ICH-E3, SAE, CSR), and patient documentation…

    32k GitHub starsUsed in 11 repos~9.9k tokens
    Legal & ComplianceAuto-check: notes
  • Clinical Research

    alirezarezvani/claude-skills

    A skill your agent uses when designing a prospective clinical study before submission — selecting and classifying endpoints (primary / key-secondary / exploratory, with surrogate-endpoint flagging)…

    28k GitHub stars~2.7k tokensUpdated 1 mo ago
    Research & ScienceAuto-check passed
  • Clinical Decision Support

    K-Dense-AI/scientific-agent-skills

    Prepares and validates research-only clinical decision-support evaluation, evidence-profile, cohort, survival, biomarker/model, privacy, and governance artifacts.

    48k GitHub starsUsed in 1 repo~3.5k tokens
    Research & ScienceAuto-check passed
  • Radiology Clinical Domain

    huang-sir1/radiology-skills

    Set disease pathways, endpoints, reference standards and treatment timelines; not patient care.

    1.9k GitHub stars~2.9k tokensUpdated 18 days ago
    Research & ScienceAuto-check passed
  • Sitemap Domain

    thedaviddias/Front-End-Checklist

    A skill your agent uses when applies to sites that have recently migrated from HTTP to HTTPS, changed domain name, or have www/non-www redirect configurations.

    74k GitHub stars~531 tokensUpdated 3 days ago
    Marketing & SEOAuto-check passed

More from RConsortium/pharma-skills

All 13 skills in this repo
  • Rounding

    RConsortium/pharma-skills

    Audit R code that prepares CSR/TLF statistics for SAS-compatible rounding compliance (ties away from zero, round-once-at-display, fixed trailing-zero precision).

    119 GitHub stars~3.8k tokensUpdated 5 days ago
    Auto-check passed
  • Issue To Eval

    RConsortium/pharma-skills

    Converts one or more GitHub Issues into standardized benchmark data using automated scripts.

    119 GitHub stars~463 tokensUpdated 5 days ago
    Auto-check passed
  • Weekly Summary

    RConsortium/pharma-skills

    Generate a concise weekly progress summary for the pharmaskills repository.

    119 GitHub stars~546 tokensUpdated 5 days ago
    Auto-check passed
  • Admiral Adae

    RConsortium/pharma-skills

    Derives an ADaM Adverse Events Analysis Dataset (ADAE) using the {admiral} R package and pharmaverse ecosystem.

    119 GitHub stars~3.9k tokensUpdated 5 days ago
    Auto-check passed
  • Admiral Adsl

    RConsortium/pharma-skills

    Derives an ADaM Subject-Level Analysis Dataset (ADSL) using the {admiral} R package and pharmaverse ecosystem.

    119 GitHub stars~4.4k tokensUpdated 5 days ago
    Auto-check passed
  • Admiral Bds

    RConsortium/pharma-skills

    Derives ADaM Basic Data Structure (BDS) datasets using the {admiral} R package.

    119 GitHub stars~3.6k tokensUpdated 5 days ago
    Auto-check passed

Questions about Sdtm Oak

What does Sdtm Oak do?

Derives CDISC SDTM domains from raw clinical (EDC/eCRF) data using the {sdtm.oak} R package. Sdtm Oak is an agent skill from RConsortium/pharma-skills.oak} R package.

When should I use Sdtm Oak?

Sdtm Oak fits situations like: A user needs to map raw study data to SDTM Events (AE; interventions (EX) domains following the sdtm.oak algorithm framework.

How do I install Sdtm Oak in Claude Code?

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

How do I install Sdtm Oak in Codex?

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

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

What does Sdtm Oak need to run?

SKILL.md names no scripts, command-line tools or credentials: Sdtm Oak is instructions for the agent only. Compatibility (from SKILL.md): Requires R with sdtm.oak (>= 0.2.0), dplyr, and tibble installed. Requires raw EDC/eCRF data and a controlled terminology (CT) specification CSV. Designed for use in a GxP-compliant environment. .

Does Sdtm Oak access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Sdtm Oak 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 Sdtm Oak use?

Sdtm Oak is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Sdtm Oak use?

About 3.9k tokens (SKILL.md is roughly 16k 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 1.4k tokens, read only when the agent opens those files.

What are the alternatives to Sdtm Oak?

Skills that share tags, products or a category with Sdtm Oak: Bio Clinical Biostatistics Cdisc Data (GPTomics/bioSkills, 1.2k stars), Clinical Reports (davila7/claude-code-templates, 32k stars), Clinical Research (alirezarezvani/claude-skills, 28k stars) and Clinical Decision Support (K-Dense-AI/scientific-agent-skills, 48k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Sdtm Oak?

RConsortium (a GitHub organization) maintains it in RConsortium/pharma-skills, which has 119 GitHub stars. The repository holds 13 skills in this directory. The repository was last updated on October 4, 2026.

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