Agent skill

Admiral Adtte

by RConsortium in RConsortium/pharma-skills

Derives an ADaM Time-to-Event Analysis Dataset (ADTTE) using the {admiral} R package.

MITAuto-check passed

Install Admiral Adtte

skills CLI
$ npx skills add RConsortium/pharma-skills --skill admiral-adtte -a claude-code

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

GitHub CLI
$ gh skill install RConsortium/pharma-skills admiral-adtte --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/admiral/admiral-adtte .claude/skills/admiral-adtte && 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
admiral-adtte
GitHub stars
120
Token cost
~3.2k tokens
SKILL.md length
838 words
Files
5
Skills in repo
13
Repo updated
First seen
Licence
MIT

At a glance

Derives an ADaM Time-to-Event Analysis Dataset (ADTTE) using the {admiral} R package.

  • Works in 10 steps: Setup and domain loading → DOMAIN removal → Merge ADSL backbone variables → …
  • A user needs to create ADTTE from SDTM event domains (AE
  • SKILL.md covers Inputs, Workflow, Multiple TTE parameters and Common errors to avoid, plus 1 more section
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Admiral Adtte is an agent skill from RConsortium/pharma-skills. Derives an ADaM Time-to-Event Analysis Dataset (ADTTE) using the {admiral} R package. Use when a user needs to create ADTTE from SDTM event domains (AE, DS, CE) and ADSL, define event and censoring conditions, derive AVAL in days, and generate QC-ready R code following CDISC ADaM BDS-TTE conventions. Requires SDTM source domains, a completed ADSL, and an ADaM ADTTE specification that defines the event and censoring rules.

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files (for example `DESIGN.md`, `README.md` and `benchmarks/README.md`). Compatibility notes: Requires R with admiral, dplyr, lubridate, and pharmaversesdtm installed. Requires a completed ADSL dataset with TRTSDT and TRTEDT. Designed for use in a…

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 create ADTTE from SDTM event domains (AE
  • Define event and censoring conditions
  • Derive AVAL in days
  • Generate QC-ready R code following CDISC ADaM BDS-TTE conventions

Example prompts

  • “Use the admiral-adtte skill to derive an ADaM Time-to-Event Analysis Dataset (ADTTE) using the {admiral} R package”
  • “/admiral-adtte”

Requirements

  • Compatibility (from SKILL.md): Requires R with admiral, dplyr, lubridate, and pharmaversesdtm installed. Requires a completed ADSL dataset with TRTSDT and TRTEDT. Designed for use in a GxP-compliant environment with access to SDTM event domain data and an ADaM ADTTE specification defining event and censoring rules.

Workflow steps

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

  1. Setup and domain loading
  2. DOMAIN removal
  3. Merge ADSL backbone variables
  4. Derive event dates on source domain
  5. Define event source objects
  6. Define censoring source objects
  7. Derive ADTTE parameter
  8. Derive AVAL (duration in days)
  9. Verification and structural assertions
  10. Final checks

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 admiral, dplyr, lubridate, and pharmaversesdtm installed. Requires a completed ADSL dataset with TRTSDT and TRTEDT. Designed for use in a GxP-compliant environment with access to SDTM event domain data and an ADaM ADTTE specification defining event and censoring rules.

    From compatibility in the SKILL.md frontmatter.

Context cost

Admiral Adtte loads about 3.2k tokens when it runs. Until then it costs about 110 tokens; SKILL.md has 838 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~110
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k

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). 838 words, ~3,176 tokens.

Download SKILL.mdSave it as .claude/skills/admiral-adtte/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.
name
admiral-adtte
description
Derives an ADaM Time-to-Event Analysis Dataset (ADTTE) using the {admiral} R package. Use when a user needs to create ADTTE from SDTM event domains (AE, DS, CE) and ADSL, define event and censoring conditions, derive AVAL in days, and generate QC-ready R code following CDISC ADaM BDS-TTE conventions. Requires SDTM source domains, a completed ADSL, and an ADaM ADTTE specification that defines the event and censoring rules.
compatibility
Requires R with admiral, dplyr, lubridate, and pharmaversesdtm installed. Requires a completed ADSL dataset with TRTSDT and TRTEDT. Designed for use in a GxP-compliant environment with access to SDTM event domain data and an ADaM ADTTE specification defining event and censoring rules.
license
MIT
metadata.author
Navitas Data Sciences
metadata.version
0.1
metadata.pharmaverse
true
metadata.parent
admiral

admiral-adtte

Shared conventions (library setup, pipe style, date rules, flag convention, # REVIEW: annotations, stopifnot() patterns) are defined in the parent ../SKILL.md. The workflow below is ADTTE-specific.

Derives a CDISC-conformant ADTTE time-to-event dataset using {admiral}. Outputs executable, QC-ready R code with event and censoring logic fully traceable to the ADaM specification.

The primary design challenge in ADTTE is the event and censoring hierarchy: the correct event date, censoring date, and censoring reason depend entirely on the protocol-specified rules. These must be defined as named event_source() and censor_source() objects — never as inline expressions — so they can be reviewed, tested, and reused independently.


Inputs

Before generating code, confirm the following are available or explicitly noted as absent:

InputRequiredNotes
AE / DS / CEYesEvent source domain(s); which domain depends on the endpoint (AE for safety TTE, DS for EFS/PFS, CE for clinical events)
ADSLYesProvides TRTSDT (start date), TRTEDT (censoring date fallback), population flags
ADaM ADTTE specYesEvent definition, censoring hierarchy, PARAMCD/PARAM, CNSDTDSC controlled terminology
Study contextYesPost-treatment window for safety TTE, censoring date priority order, analysis population

If ADSL is absent, stop and request it. If the event source domain is absent, stop and request it — do not substitute synthetic dates.


Workflow

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

Step 1 — Setup and domain loading
r
library(admiral)
library(dplyr)
library(lubridate)
library(pharmaversesdtm)
library(pharmaverseadam)

# Load event source domain(s) — substitute with the domain(s) relevant to the endpoint
ae   <- pharmaversesdtm::ae
adsl <- pharmaverseadam::adsl  # assumed derived upstream

stopifnot(nrow(ae) > 0)
Step 2 — DOMAIN removal

Remove DOMAIN from every event source domain before passing it to derive_param_tte(). admiral errors when DOMAIN exists in both the dataset and a source_datasets entry.

r
ae <- ae |> select(-DOMAIN)
# Repeat for every source domain used in event_source() or censor_source() calls
Step 3 — Merge ADSL backbone variables

Bring required ADSL variables into the event dataset. At minimum: TRTSDT (start date for ADTTE), TRTEDT (fallback censoring date), and population flags. Always use derive_vars_merged() — not left_join().

r
# REVIEW: Confirm which ADSL variables are required per the ADTTE spec.
#   TRTSDT is the conventional STARTDT for most TTE parameters. If the endpoint
#   uses randomization date instead, use RANDDT. Add population flags as needed.
adtte <- ae |>
  derive_vars_merged(
    dataset_add = adsl,
    by_vars     = exprs(STUDYID, USUBJID),
    new_vars    = exprs(TRTSDT, TRTEDT, TRT01P, TRT01PN, TRT01A, TRT01AN,
                        SAFFL, ITTFL)
  )
Step 4 — Derive event dates on source domain

Convert DTC dates in the source domain to analysis dates using derive_vars_dt() before referencing them in event_source() or censor_source(). Never use as.Date() on DTC variables.

r
adtte <- adtte |>
  derive_vars_dt(
    dtc             = AESTDTC,
    new_vars_prefix = "AST",
    date_imputation = "first",
    flag_imputation = "auto"
  )
Step 5 — Define event source objects

Define event conditions as named event_source() objects. Never define them inline inside derive_param_tte() — named objects are independently testable and reviewable.

r
# REVIEW: The event filter below (AESER == "Y") is the most common definition
#   for a time-to-first-serious-AE endpoint. Confirm the exact event definition
#   from the ADaM ADTTE spec and SAP:
#   - Which AE terms or flags qualify? (AESER, AETOXGR >= 3, specific AEDECOD terms)
#   - Does the event require onset during treatment only, or ever?
#   - What is the event date — onset (ASTDT) or report date?
ttae_event <- event_source(
  dataset_name  = "ae",
  filter        = AESER == "Y",          # PLACEHOLDER — confirm from SAP
  date          = ASTDT,
  set_values_to = exprs(
    EVNTDESC = "Serious adverse event",
    SRCDOM   = "AE",
    SRCVAR   = "AESTDTC",
    SRCSEQ   = AESEQ
  )
)
Step 6 — Define censoring source objects

Define censoring conditions as named censor_source() objects in priority order (first entry wins when multiple dates are available for a subject).

r
# REVIEW: The censoring date below (TRTEDT + 30) is a common proxy for
#   "30 days post last dose" TTE endpoints. Confirm the censoring hierarchy
#   from the ADaM ADTTE spec and SAP:
#   - What is the primary censoring date? (last contact, last dose + window, LSDT)
#   - Is the post-treatment window 30, 28, or another number of days?
#   - What is CNSDTDSC for each censoring type? Confirm against define.xml CT.
ttae_censor <- censor_source(
  dataset_name  = "adsl",
  date          = TRTEDT + 30,           # PLACEHOLDER — confirm from SAP
  set_values_to = exprs(
    EVNTDESC = NA_character_,
    # REVIEW: CNSDTDSC must match define.xml controlled terminology exactly.
    #   Common values: "Last dose date + 30 days", "Last known alive date",
    #   "End of study". Confirm the full list and exact strings from the spec.
    CNSDTDSC = "Last dose date + 30 days",   # PLACEHOLDER — confirm CT from spec
    SRCDOM   = "ADSL",
    SRCVAR   = "TRTEDT"
  )
)
Step 7 — Derive ADTTE parameter

Call derive_param_tte() with the named source objects. Pass all source domains referenced by event or censor sources in source_datasets.

r
# REVIEW: PARAMCD and PARAM must match the ADaM ADTTE spec exactly.
adtte <- derive_param_tte(
  dataset_adsl      = adsl,
  source_datasets   = list(adsl = adsl, ae = ae),
  start_date        = TRTSDT,
  event_conditions  = list(ttae_event),
  censor_conditions = list(ttae_censor),
  set_values_to     = exprs(
    PARAMCD = "TTAE",
    PARAM   = "Time to First Serious Adverse Event"
  )
)
Step 8 — Derive AVAL (duration in days)

AVAL is the time from STARTDT to the event or censoring date (ADT) in days. Use derive_vars_duration(). CDISC convention requires AVAL ≥ 1: a subject who events on Day 1 has AVAL = 1, not 0 (add_one = TRUE).

r
adtte <- adtte |>
  derive_vars_duration(
    new_var      = AVAL,
    start_date   = STARTDT,
    end_date     = ADT,
    out_unit     = "days",
    add_one      = TRUE,    # CDISC: AVAL = 1 when event/censoring on start date
    trunc_out    = FALSE
  )
Step 9 — Verification and structural assertions

Print event and censoring counts and assert structural requirements before finalising the dataset.

r
# Print event/censor summary — inspect for implausible counts before proceeding
event_summary <- adtte |>
  count(PARAMCD, CNSR)
print(event_summary)

# CNSR must be integer 0 (event) or 1 (censored) — never logical or character
stopifnot(all(adtte$CNSR %in% c(0L, 1L)))

# AVAL must be strictly positive — CDISC requires >= 1 day
stopifnot(all(adtte$AVAL >= 1, na.rm = TRUE))

# CNSDTDSC must be non-missing for every censored subject
stopifnot(!any(adtte$CNSR == 1L & is.na(adtte$CNSDTDSC)))

# EVNTDESC must be non-missing for every subject with an event
stopifnot(!any(adtte$CNSR == 0L & is.na(adtte$EVNTDESC)))
Step 10 — Final checks
r
# Uniqueness: one record per subject per PARAMCD
dup_check <- adtte |>
  count(STUDYID, USUBJID, PARAMCD) |>
  filter(n > 1)
if (nrow(dup_check) > 0) {
  stop("Duplicate subject-PARAMCD records found:\n",
       paste(paste(dup_check$USUBJID, dup_check$PARAMCD), collapse = "\n"))
}

# Required variable presence check
required_vars <- c(
  "STUDYID", "USUBJID", "PARAMCD", "PARAM",
  "AVAL", "CNSR", "CNSDTDSC", "EVNTDESC",
  "ADT", "STARTDT"
)
missing_vars <- setdiff(required_vars, names(adtte))
if (length(missing_vars) > 0) {
  stop("Missing required ADTTE variables: ", paste(missing_vars, collapse = ", "))
}

Multiple TTE parameters

When the spec requires more than one TTE parameter (e.g., TTAE and TTFAE — time-to-first AE, any grade), repeat Steps 5–7 for each parameter with its own named source objects. Keep naming consistent: {param}_event and {param}_censor.

r
# Example: adding a second parameter (time to any AE, grade ≥ 3)
ttae3_event <- event_source(
  dataset_name  = "ae",
  filter        = AETOXGR >= 3,         # REVIEW — confirm grading threshold from SAP
  date          = ASTDT,
  set_values_to = exprs(
    EVNTDESC = "Grade 3+ adverse event",
    SRCDOM = "AE", SRCVAR = "AESTDTC", SRCSEQ = AESEQ
  )
)

adtte <- adtte |>
  derive_param_tte(
    dataset_adsl      = adsl,
    source_datasets   = list(adsl = adsl, ae = ae),
    start_date        = TRTSDT,
    event_conditions  = list(ttae3_event),
    censor_conditions = list(ttae_censor),   # reuse common censoring rule
    set_values_to     = exprs(
      PARAMCD = "TTAE3",
      PARAM   = "Time to First Grade 3+ Adverse Event"
    )
  )

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

Common errors to avoid

  • Using left_join() for the ADSL merge instead of derive_vars_merged() — left_join() does not apply admiral's key-variable validation and can silently produce a many-to-many join if ADSL has unexpected duplicates
  • Defining event and censor sources inline inside derive_param_tte() — inline definitions cannot be unit-tested or reused across parameters; always define as named objects
  • Not removing DOMAIN from source domains before derive_param_tte() — causes variable conflict errors; remove in Step 2, before any derivation
  • Hardcoding the censoring date (e.g., TRTEDT + 30) without a # REVIEW: comment — the censoring window is protocol-specific and must come from the SAP
  • Using CNSR = TRUE/FALSE instead of CNSR = 0L/1L — CDISC requires integer; logical values will fail downstream QC checks and define.xml validation
  • AVAL = 0 for same-day events — add_one = TRUE in derive_vars_duration() is required to meet the CDISC ≥1 day constraint; never omit it
  • Hardcoding CNSDTDSC text without a # REVIEW: comment — the exact string must match define.xml controlled terminology; a mismatch causes submission review findings
  • Not printing event/censor counts — if all subjects are censored due to a misconfigured date expression, the dataset looks structurally valid but the analysis is wrong; always print counts before finalising
  • Using as.Date() on DTC variables in event source filters — use derive_vars_dt() first; as.Date() silently returns NA for partial dates

Output checklist

Before returning code, verify:

  • DOMAIN removed from every source domain before derive_param_tte() (Step 2)
  • ADSL merged with derive_vars_merged(), not left_join() (Step 3)
  • Event date derived with derive_vars_dt() before use in event_source() (Step 4)
  • Event and censor conditions defined as named objects, not inline (Steps 5–6)
  • # REVIEW: at event filter condition (Step 5)
  • # REVIEW: at censoring date expression (Step 6)
  • # REVIEW: at CNSDTDSC text (Step 6)
  • # REVIEW: at PARAMCD/PARAM (Step 7)
  • AVAL derived with derive_vars_duration() with add_one = TRUE (Step 8)
  • Event/censor counts printed to console (Step 9)
  • stopifnot(all(CNSR %in% c(0L, 1L))) present (Step 9)
  • stopifnot(all(AVAL >= 1)) present (Step 9)
  • CNSDTDSC non-missing where CNSR == 1 assertion present (Step 9)
  • EVNTDESC non-missing where CNSR == 0 assertion present (Step 9)
  • Uniqueness assertion per USUBJID × PARAMCD (Step 10)
  • Required variable presence check (Step 10)

© 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 4 other files in admiral/admiral-adtte of RConsortium/pharma-skills.

  • SKILL.md
  • DESIGN.md
  • LICENSE
  • README.md
  • benchmarks/README.md

Open the folder on GitHubat commit ae5d83b

Compare with similar skills

Admiral Adtte 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.

Admiral Adtte compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Admiral Adtte this skillRConsortium/pharma-skills120—~3.2kAutomated safety check: PassMIT
Eventscoreyhaines31/marketingskills54k—~3kAutomated safety check: PassMIT
Event Sourcing Architectdavila7/claude-code-templates33k4 repos~659Automated safety check: PassMIT
Event Store Designwshobson/agents40k9 repos~828Automated safety check: PassMIT
DatasetsArize-ai/phoenix12k—~1.6kAutomated safety check: PassCustom licence
Event Delegationthedaviddias/Front-End-Checklist74k—~500Automated safety check: PassMIT

Similar skills

  • Events

    coreyhaines31/marketingskills

    When the user wants to plan, run, sponsor, speak at, or get pipeline from events — webinars, conferences, trade shows, meetups, dinners, workshops, virtual summits, or user conferences.

    54k GitHub stars~3k tokensUpdated 2 days ago
    Marketing & SEOAuto-check passed
  • Event Sourcing Architect

    davila7/claude-code-templates

    Expert in event sourcing, CQRS, and event-driven architecture patterns.

    33k GitHub starsUsed in 4 repos~659 tokens
    Backend & APIsAuto-check passed
  • Event Store Design

    wshobson/agents

    Designs event stores for event-sourced systems: requirements, a comparison of EventStoreDB, PostgreSQL, Kafka, DynamoDB and Marten, and stream and versioning practices.

    40k GitHub starsUsed in 9 repos~828 tokens
    Backend & APIsAuto-check passed
  • Datasets

    Arize-ai/phoenix

    Understand what a Phoenix dataset is and reason well about its examples, outputs, splits, and how it feeds evaluators and experiments.

    12k GitHub stars~1.6k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed
  • Event Delegation

    thedaviddias/Front-End-Checklist

    A skill your agent uses when reviewing scripts, client components, bundles, or runtime behavior related to Use event delegation for dynamic content.

    74k GitHub stars~500 tokensUpdated 4 days ago
    Auto-check passed
  • Scores news, announcements and macro events with the LLM, stores them in an event CSV and blends the decaying event signal with technical signals in signal_engine.py.

    35k GitHub stars~2.1k tokensUpdated today
    Business, Finance & HRAuto-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).

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

    RConsortium/pharma-skills

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

    120 GitHub stars~463 tokensUpdated 7 days ago
    Auto-check passed
  • Weekly Summary

    RConsortium/pharma-skills

    Generate a concise weekly progress summary for the pharmaskills repository.

    120 GitHub stars~546 tokensUpdated 7 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.

    120 GitHub stars~3.9k tokensUpdated 7 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.

    120 GitHub stars~4.4k tokensUpdated 7 days ago
    Auto-check passed
  • Admiral Bds

    RConsortium/pharma-skills

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

    120 GitHub stars~3.6k tokensUpdated 7 days ago
    Auto-check passed

Questions about Admiral Adtte

What does Admiral Adtte do?

Derives an ADaM Time-to-Event Analysis Dataset (ADTTE) using the {admiral} R package. Admiral Adtte is an agent skill from RConsortium/pharma-skills. Derives an ADaM Time-to-Event Analysis Dataset (ADTTE) using the {admiral} R package.

When should I use Admiral Adtte?

Admiral Adtte fits situations like: A user needs to create ADTTE from SDTM event domains (AE; define event and censoring conditions; derive AVAL in days; generate QC-ready R code following CDISC ADaM BDS-TTE conventions.

How do I install Admiral Adtte in Claude Code?

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

How do I install Admiral Adtte in Codex?

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

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

What does Admiral Adtte need to run?

SKILL.md names no scripts, command-line tools or credentials: Admiral Adtte is instructions for the agent only. Compatibility (from SKILL.md): Requires R with admiral, dplyr, lubridate, and pharmaversesdtm installed. Requires a completed ADSL dataset with TRTSDT and TRTEDT. Designed for use in a GxP-compliant environment with access to SDTM event domain data and an ADaM ADTTE specification defining event and censoring rules. .

Does Admiral Adtte 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 Admiral Adtte 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 Admiral Adtte use?

Admiral Adtte 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 Admiral Adtte use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Admiral Adtte?

Skills that share tags, products or a category with Admiral Adtte: Events (coreyhaines31/marketingskills, 54k stars), Event Sourcing Architect (davila7/claude-code-templates, 33k stars), Event Store Design (wshobson/agents, 40k stars) and Datasets (Arize-ai/phoenix, 12k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Admiral Adtte?

RConsortium (a GitHub organization) maintains it in RConsortium/pharma-skills, which has 120 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.