New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

scikit-survival Time-to-Event Modeling

by davila7 in davila7/claude-code-templates

Fits and evaluates survival models with scikit-survival: Cox models, Random Survival Forests, boosting, survival SVMs, concordance index, Brier score and competing risks.

MITAuto-check passedData & Analytics

Install scikit-survival Time-to-Event Modeling

skills CLI
$ npx skills add davila7/claude-code-templates --skill scikit-survival -a claude-code

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

GitHub CLI
$ gh skill install davila7/claude-code-templates scikit-survival --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/davila7/claude-code-templates.git skills-src && mkdir -p .claude/skills && cp -r skills-src/cli-tool/components/skills/scientific/scikit-survival .claude/skills/scikit-survival && 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
scikit-survival
GitHub stars
32k
Used in
11 other repos
Token cost
~3.7k tokens
SKILL.md length
881 words
Files
7 (incl. references)
Skills in repo
478
Repo updated
First seen
Licence
MIT

At a glance

Fits and evaluates survival models with scikit-survival: Cox models, Random Survival Forests, boosting, survival SVMs, concordance index, Brier score and competing risks.

  • Works in 5 steps: Model Types and Selection → Data Preparation and Preprocessing → Model Evaluation → …
  • Fitting a Cox proportional hazards model to censored patient data
  • SKILL.md covers Overview, When to Use This Skill, Core Capabilities and Typical Workflows, plus 6 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

scikit-survival is a Python library built on scikit-learn for time-to-event analysis on censored data, where some observations are only partly known. The skill helps the agent choose among model families: Cox proportional hazards models including a penalized elastic-net variant, ensemble methods such as Random Survival Forest, gradient boosting and Extra Survival Trees, and survival support vector machines for medium-sized datasets.

It also covers right-, left- and interval-censored data, preprocessing and missing values, evaluation with the concordance index, Brier score and time-dependent AUC, Kaplan-Meier and Nelson-Aalen curves, and competing risks. Reference files are split by topic: Cox models, ensemble models, SVM models, data handling, evaluation metrics and competing risks.

When your agent uses it

  • Fitting a Cox proportional hazards model to censored patient data
  • Training a Random Survival Forest and comparing it with a Cox baseline
  • Scoring survival predictions with concordance index or Brier score
  • Analyzing competing risks or plotting Kaplan-Meier curves

Example prompts

  • “Fit a penalized Cox model on trial_data.csv with time and event columns and report the concordance index.”
  • “Compare a Random Survival Forest and gradient boosting on this censored dataset using the Brier score.”
  • “Plot Kaplan-Meier curves for the two treatment arms in my cohort.”

Requirements

  • Python with `scikit-survival` and scikit-learn

Workflow steps

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

  1. Model Types and Selection
  2. Data Preparation and Preprocessing
  3. Model Evaluation
  4. Competing Risks Analysis
  5. Non-parametric Estimation

What it can do on your machine

Read from SKILL.md and the folder at commit 46b4d8b. 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 python).

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

  • Network

    Links to these hosts (documentation or services it may open):

    • scikit-survival.readthedocs.io
    • github.com

    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

scikit-survival Time-to-Event Modeling loads about 3.7k tokens when it runs, and up to ~19k if it reads all its reference files. Until then it costs about 120 tokens; SKILL.md has 881 words of instructions outside code blocks.

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

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 davila7/claude-code-templates at commit 46b4d8b, republished under its MIT licence (© davila7). 881 words, ~3,724 tokens.

Download SKILL.mdSave it as .claude/skills/scikit-survival/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
scikit-survival
description
Comprehensive toolkit for survival analysis and time-to-event modeling in Python using scikit-survival. Use this skill when working with censored survival data, performing time-to-event analysis, fitting Cox models, Random Survival Forests, Gradient Boosting models, or Survival SVMs, evaluating survival predictions with concordance index or Brier score, handling competing risks, or implementing any survival analysis workflow with the scikit-survival library.

scikit-survival: Survival Analysis in Python

Overview

scikit-survival is a Python library for survival analysis built on top of scikit-learn. It provides specialized tools for time-to-event analysis, handling the unique challenge of censored data where some observations are only partially known.

Survival analysis aims to establish connections between covariates and the time of an event, accounting for censored records (particularly right-censored data from studies where participants don't experience events during observation periods).

When to Use This Skill

Use this skill when:

  • Performing survival analysis or time-to-event modeling
  • Working with censored data (right-censored, left-censored, or interval-censored)
  • Fitting Cox proportional hazards models (standard or penalized)
  • Building ensemble survival models (Random Survival Forests, Gradient Boosting)
  • Training Survival Support Vector Machines
  • Evaluating survival model performance (concordance index, Brier score, time-dependent AUC)
  • Estimating Kaplan-Meier or Nelson-Aalen curves
  • Analyzing competing risks
  • Preprocessing survival data or handling missing values in survival datasets
  • Conducting any analysis using the scikit-survival library

Core Capabilities

1. Model Types and Selection

scikit-survival provides multiple model families, each suited for different scenarios:

Cox Proportional Hazards Models

Use for: Standard survival analysis with interpretable coefficients

  • CoxPHSurvivalAnalysis: Basic Cox model
  • CoxnetSurvivalAnalysis: Penalized Cox with elastic net for high-dimensional data
  • IPCRidge: Ridge regression for accelerated failure time models

See: references/cox-models.md for detailed guidance on Cox models, regularization, and interpretation

Ensemble Methods

Use for: High predictive performance with complex non-linear relationships

  • RandomSurvivalForest: Robust, non-parametric ensemble method
  • GradientBoostingSurvivalAnalysis: Tree-based boosting for maximum performance
  • ComponentwiseGradientBoostingSurvivalAnalysis: Linear boosting with feature selection
  • ExtraSurvivalTrees: Extremely randomized trees for additional regularization

See: references/ensemble-models.md for comprehensive guidance on ensemble methods, hyperparameter tuning, and when to use each model

Survival Support Vector Machines

Use for: Medium-sized datasets with margin-based learning

  • FastSurvivalSVM: Linear SVM optimized for speed
  • FastKernelSurvivalSVM: Kernel SVM for non-linear relationships
  • HingeLossSurvivalSVM: SVM with hinge loss
  • ClinicalKernelTransform: Specialized kernel for clinical + molecular data

See: references/svm-models.md for detailed SVM guidance, kernel selection, and hyperparameter tuning

Model Selection Decision Tree
Start
├─ High-dimensional data (p > n)?
│  ├─ Yes → CoxnetSurvivalAnalysis (elastic net)
│  └─ No → Continue
│
├─ Need interpretable coefficients?
│  ├─ Yes → CoxPHSurvivalAnalysis or ComponentwiseGradientBoostingSurvivalAnalysis
│  └─ No → Continue
│
├─ Complex non-linear relationships expected?
│  ├─ Yes
│  │  ├─ Large dataset (n > 1000) → GradientBoostingSurvivalAnalysis
│  │  ├─ Medium dataset → RandomSurvivalForest or FastKernelSurvivalSVM
│  │  └─ Small dataset → RandomSurvivalForest
│  └─ No → CoxPHSurvivalAnalysis or FastSurvivalSVM
│
└─ For maximum performance → Try multiple models and compare
2. Data Preparation and Preprocessing

Before modeling, properly prepare survival data:

Creating Survival Outcomes
python
from sksurv.util import Surv

# From separate arrays
y = Surv.from_arrays(event=event_array, time=time_array)

# From DataFrame
y = Surv.from_dataframe('event', 'time', df)
Essential Preprocessing Steps
  1. Handle missing values: Imputation strategies for features
  2. Encode categorical variables: One-hot encoding or label encoding
  3. Standardize features: Critical for SVMs and regularized Cox models
  4. Validate data quality: Check for negative times, sufficient events per feature
  5. Train-test split: Maintain similar censoring rates across splits

See: references/data-handling.md for complete preprocessing workflows, data validation, and best practices

3. Model Evaluation

Proper evaluation is critical for survival models. Use appropriate metrics that account for censoring:

Concordance Index (C-index)

Primary metric for ranking/discrimination:

  • Harrell's C-index: Use for low censoring (<40%)
  • Uno's C-index: Use for moderate to high censoring (>40%) - more robust
python
from sksurv.metrics import concordance_index_censored, concordance_index_ipcw

# Harrell's C-index
c_harrell = concordance_index_censored(y_test['event'], y_test['time'], risk_scores)[0]

# Uno's C-index (recommended)
c_uno = concordance_index_ipcw(y_train, y_test, risk_scores)[0]
Time-Dependent AUC

Evaluate discrimination at specific time points:

python
from sksurv.metrics import cumulative_dynamic_auc

times = [365, 730, 1095]  # 1, 2, 3 years
auc, mean_auc = cumulative_dynamic_auc(y_train, y_test, risk_scores, times)
Brier Score

Assess both discrimination and calibration:

python
from sksurv.metrics import integrated_brier_score

ibs = integrated_brier_score(y_train, y_test, survival_functions, times)

See: references/evaluation-metrics.md for comprehensive evaluation guidance, metric selection, and using scorers with cross-validation

4. Competing Risks Analysis

Handle situations with multiple mutually exclusive event types:

python
from sksurv.nonparametric import cumulative_incidence_competing_risks

# Estimate cumulative incidence for each event type
time_points, cif_event1, cif_event2 = cumulative_incidence_competing_risks(y)

Use competing risks when:

  • Multiple mutually exclusive event types exist (e.g., death from different causes)
  • Occurrence of one event prevents others
  • Need probability estimates for specific event types

See: references/competing-risks.md for detailed competing risks methods, cause-specific hazard models, and interpretation

5. Non-parametric Estimation

Estimate survival functions without parametric assumptions:

Kaplan-Meier Estimator
python
from sksurv.nonparametric import kaplan_meier_estimator

time, survival_prob = kaplan_meier_estimator(y['event'], y['time'])
Nelson-Aalen Estimator
python
from sksurv.nonparametric import nelson_aalen_estimator

time, cumulative_hazard = nelson_aalen_estimator(y['event'], y['time'])

Typical Workflows

Workflow 1: Standard Survival Analysis
python
from sksurv.datasets import load_breast_cancer
from sksurv.linear_model import CoxPHSurvivalAnalysis
from sksurv.metrics import concordance_index_ipcw
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 1. Load and prepare data
X, y = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 2. Preprocess
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 3. Fit model
estimator = CoxPHSurvivalAnalysis()
estimator.fit(X_train_scaled, y_train)

# 4. Predict
risk_scores = estimator.predict(X_test_scaled)

# 5. Evaluate
c_index = concordance_index_ipcw(y_train, y_test, risk_scores)[0]
print(f"C-index: {c_index:.3f}")
Show full SKILL.md (350 more words)Show less
Workflow 2: High-Dimensional Data with Feature Selection
python
from sksurv.linear_model import CoxnetSurvivalAnalysis
from sklearn.model_selection import GridSearchCV
from sksurv.metrics import as_concordance_index_ipcw_scorer

# 1. Use penalized Cox for feature selection
estimator = CoxnetSurvivalAnalysis(l1_ratio=0.9)  # Lasso-like

# 2. Tune regularization with cross-validation
param_grid = {'alpha_min_ratio': [0.01, 0.001]}
cv = GridSearchCV(estimator, param_grid,
                  scoring=as_concordance_index_ipcw_scorer(), cv=5)
cv.fit(X, y)

# 3. Identify selected features
best_model = cv.best_estimator_
selected_features = np.where(best_model.coef_ != 0)[0]
Workflow 3: Ensemble Method for Maximum Performance
python
from sksurv.ensemble import GradientBoostingSurvivalAnalysis
from sklearn.model_selection import GridSearchCV

# 1. Define parameter grid
param_grid = {
    'learning_rate': [0.01, 0.05, 0.1],
    'n_estimators': [100, 200, 300],
    'max_depth': [3, 5, 7]
}

# 2. Grid search
gbs = GradientBoostingSurvivalAnalysis()
cv = GridSearchCV(gbs, param_grid, cv=5,
                  scoring=as_concordance_index_ipcw_scorer(), n_jobs=-1)
cv.fit(X_train, y_train)

# 3. Evaluate best model
best_model = cv.best_estimator_
risk_scores = best_model.predict(X_test)
c_index = concordance_index_ipcw(y_train, y_test, risk_scores)[0]
Workflow 4: Comprehensive Model Comparison
python
from sksurv.linear_model import CoxPHSurvivalAnalysis
from sksurv.ensemble import RandomSurvivalForest, GradientBoostingSurvivalAnalysis
from sksurv.svm import FastSurvivalSVM
from sksurv.metrics import concordance_index_ipcw, integrated_brier_score

# Define models
models = {
    'Cox': CoxPHSurvivalAnalysis(),
    'RSF': RandomSurvivalForest(n_estimators=100, random_state=42),
    'GBS': GradientBoostingSurvivalAnalysis(random_state=42),
    'SVM': FastSurvivalSVM(random_state=42)
}

# Evaluate each model
results = {}
for name, model in models.items():
    model.fit(X_train_scaled, y_train)
    risk_scores = model.predict(X_test_scaled)
    c_index = concordance_index_ipcw(y_train, y_test, risk_scores)[0]
    results[name] = c_index
    print(f"{name}: C-index = {c_index:.3f}")

# Select best model
best_model_name = max(results, key=results.get)
print(f"\nBest model: {best_model_name}")

Integration with scikit-learn

scikit-survival fully integrates with scikit-learn's ecosystem:

python
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score, GridSearchCV

# Use pipelines
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', CoxPHSurvivalAnalysis())
])

# Use cross-validation
scores = cross_val_score(pipeline, X, y, cv=5,
                         scoring=as_concordance_index_ipcw_scorer())

# Use grid search
param_grid = {'model__alpha': [0.1, 1.0, 10.0]}
cv = GridSearchCV(pipeline, param_grid, cv=5)
cv.fit(X, y)

Best Practices

  1. Always standardize features for SVMs and regularized Cox models
  2. Use Uno's C-index instead of Harrell's when censoring > 40%
  3. Report multiple evaluation metrics (C-index, integrated Brier score, time-dependent AUC)
  4. Check proportional hazards assumption for Cox models
  5. Use cross-validation for hyperparameter tuning with appropriate scorers
  6. Validate data quality before modeling (check for negative times, sufficient events per feature)
  7. Compare multiple model types to find best performance
  8. Use permutation importance for Random Survival Forests (not built-in importance)
  9. Consider competing risks when multiple event types exist
  10. Document censoring mechanism and rates in analysis

Common Pitfalls to Avoid

  1. Using Harrell's C-index with high censoring → Use Uno's C-index
  2. Not standardizing features for SVMs → Always standardize
  3. Forgetting to pass y_train to concordance_index_ipcw → Required for IPCW calculation
  4. Treating competing events as censored → Use competing risks methods
  5. Not checking for sufficient events per feature → Rule of thumb: 10+ events per feature
  6. Using built-in feature importance for RSF → Use permutation importance
  7. Ignoring proportional hazards assumption → Validate or use alternative models
  8. Not using appropriate scorers in cross-validation → Use as_concordance_index_ipcw_scorer()

Reference Files

This skill includes detailed reference files for specific topics:

  • references/cox-models.md: Complete guide to Cox proportional hazards models, penalized Cox (CoxNet), IPCRidge, regularization strategies, and interpretation
  • references/ensemble-models.md: Random Survival Forests, Gradient Boosting, hyperparameter tuning, feature importance, and model selection
  • references/evaluation-metrics.md: Concordance index (Harrell's vs Uno's), time-dependent AUC, Brier score, comprehensive evaluation pipelines
  • references/data-handling.md: Data loading, preprocessing workflows, handling missing data, feature encoding, validation checks
  • references/svm-models.md: Survival Support Vector Machines, kernel selection, clinical kernel transform, hyperparameter tuning
  • references/competing-risks.md: Competing risks analysis, cumulative incidence functions, cause-specific hazard models

Load these reference files when detailed information is needed for specific tasks.

Additional Resources

Quick Reference: Key Imports

python
# Models
from sksurv.linear_model import CoxPHSurvivalAnalysis, CoxnetSurvivalAnalysis, IPCRidge
from sksurv.ensemble import RandomSurvivalForest, GradientBoostingSurvivalAnalysis
from sksurv.svm import FastSurvivalSVM, FastKernelSurvivalSVM
from sksurv.tree import SurvivalTree

# Evaluation metrics
from sksurv.metrics import (
    concordance_index_censored,
    concordance_index_ipcw,
    cumulative_dynamic_auc,
    brier_score,
    integrated_brier_score,
    as_concordance_index_ipcw_scorer,
    as_integrated_brier_score_scorer
)

# Non-parametric estimation
from sksurv.nonparametric import (
    kaplan_meier_estimator,
    nelson_aalen_estimator,
    cumulative_incidence_competing_risks
)

# Data handling
from sksurv.util import Surv
from sksurv.preprocessing import OneHotEncoder, encode_categorical
from sksurv.datasets import load_gbsg2, load_breast_cancer, load_veterans_lung_cancer

# Kernels
from sksurv.kernels import ClinicalKernelTransform

© davila7, 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 cli-tool/components/skills/scientific/scikit-survival of davila7/claude-code-templates.

  • SKILL.md
  • references/competing-risks.md
  • references/cox-models.md
  • references/data-handling.md
  • references/ensemble-models.md
  • references/evaluation-metrics.md
  • references/svm-models.md

Open the folder on GitHubat commit 46b4d8b

Used in 11 other repositories

We found 15 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 11 other GitHub owners. This page covers the copy in davila7/claude-code-templates, which our catalogue first saw on October 7, 2026.

Compare with similar skills

scikit-survival Time-to-Event Modeling 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.

scikit-survival Time-to-Event Modeling compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
scikit-survival Time-to-Event Modeling this skilldavila7/claude-code-templates32k11 repos~3.7kAutomated safety check: PassMIT
Statistical Data Analysislingzhi227/agent-research-skills386—~886Automated safety check: PassNone
Scikit LearnzLanqing/codex-claude-academic-skills4.7k16 repos~3.9kAutomated safety check: PassBSD-3-Clause
Senior Data ScientistRaidriar7170/hermes-skilleval1255 repos~1.4kAutomated safety check: PassMIT
Time Series Analytics Useropen-edge-platform/edge-ai-libraries169—~3.1kAutomated safety check: PassApache-2.0
Precisemicroprediction/precise336—~782Automated safety check: PassMIT

Similar skills

  • Statistical Data Analysis

    lingzhi227/agent-research-skills

    Writes statistical analysis code for experimental data, runs it through a four-round review, and reports effect sizes, p-values and confidence intervals.

    386 GitHub stars~886 tokensUpdated 7 mo ago
    Data & AnalyticsAuto-check passed

  • Scikit Learn

    zLanqing/codex-claude-academic-skills

    Machine learning in Python with scikit-learn. An agent skill from zLanqing/codex-claude-academic-skills.

    4.7k GitHub starsUsed in 16 repos~3.9k tokens
    Data & AnalyticsAuto-check passed

  • Senior Data Scientist

    Raidriar7170/hermes-skilleval

    World-class data science skill for statistical modeling, experimentation, causal inference, and advanced analytics.

    125 GitHub starsUsed in 5 repos~1.4k tokens
    Data & AnalyticsAuto-check passed

  • Time Series Analytics User

    open-edge-platform/edge-ai-libraries

    Build a new time-series analytics use case on top of the deployed Time Series Analytics microservice — bring it up with Docker Compose (from a repo clone, or by fetching the compose files from…

    169 GitHub stars~3.1k tokensUpdated today
    Data & AnalyticsAuto-check passed

  • Precise

    microprediction/precise

    Online (incremental) covariance, correlation, and precision estimation in Python — the streaming complement to sklearn.covariance.

    336 GitHub stars~782 tokensUpdated 3 days ago
    Data & AnalyticsAuto-check passed

  • Machine Learning Trading Strategy

    HKUDS/Vibe-Trading

    Trains scikit-learn models with walk-forward validation on features from OHLCV data to predict return direction and turn the predictions into trading signals.

    35k GitHub stars~3.2k tokensUpdated yesterday
    Data & AnalyticsAuto-check passed

More from davila7/claude-code-templates

All 478 skills in this repo

  • Perplexity Web Search

    davila7/claude-code-templates

    Runs web-grounded searches through Perplexity's Sonar models over OpenRouter for current events, recent literature and cited facts beyond the model's training cutoff.

    32k GitHub starsUsed in 11 repos~3.5k tokens
    Auto-check: notes

  • Neuropixels Data Analysis

    davila7/claude-code-templates

    Analyzes Neuropixels recordings from SpikeGLX or Open Ephys through preprocessing, drift correction, Kilosort4 spike sorting, quality metrics and curation.

    32k GitHub starsUsed in 9 repos~2.8k tokens
    Auto-check passed

  • Scientific Venue Templates

    davila7/claude-code-templates

    Supplies LaTeX templates and formatting rules for journals, conferences, posters, and grant proposals, then can check a draft against them.

    32k GitHub starsUsed in 9 repos~5.1k tokens
    Auto-check: notes

  • Brand Voice Content Creator

    davila7/claude-code-templates

    Analyzes a brand's existing writing to lock in a consistent voice, then builds SEO blog posts and platform-specific social content around it.

    32k GitHub starsUsed in 3 repos~1.9k tokens
    Auto-check passed

  • CAPA Officer

    davila7/claude-code-templates

    Guides corrective and preventive action (CAPA) work in a quality management system, from initiation and root cause analysis through effectiveness verification.

    32k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed

  • Fda Consultant Specialist

    davila7/claude-code-templates

    Senior FDA consultant and specialist for medical device companies including HIPAA compliance and requirement management.

    32k GitHub starsUsed in 1 repo~2.7k tokens
    Auto-check passed

Works with

Categories

Questions about scikit-survival Time-to-Event Modeling

What does scikit-survival Time-to-Event Modeling do?

Fits and evaluates survival models with scikit-survival: Cox models, Random Survival Forests, boosting, survival SVMs, concordance index, Brier score and competing risks. scikit-survival is a Python library built on scikit-learn for time-to-event analysis on censored data, where some observations are only partly known. The skill helps the agent choose among model families: Cox proportional hazards models including a penalized elastic-net variant, ensemble methods such as Random Survival Forest, gradient boosting and Extra Survival Trees, and survival support vector machines for medium-sized datasets.

When should I use scikit-survival Time-to-Event Modeling?

scikit-survival Time-to-Event Modeling fits situations like: fitting a Cox proportional hazards model to censored patient data; training a Random Survival Forest and comparing it with a Cox baseline; scoring survival predictions with concordance index or Brier score; analyzing competing risks or plotting Kaplan-Meier curves.

How do I install scikit-survival Time-to-Event Modeling in Claude Code?

Run `npx skills add davila7/claude-code-templates --skill scikit-survival -a claude-code`. Or copy the skill folder (cli-tool/components/skills/scientific/scikit-survival in davila7/claude-code-templates) into .claude/skills/scikit-survival in your project. Claude Code loads it when a task matches its description.

How do I install scikit-survival Time-to-Event Modeling in Codex?

Run `npx skills add davila7/claude-code-templates --skill scikit-survival -a codex`. Or copy the skill folder (cli-tool/components/skills/scientific/scikit-survival in davila7/claude-code-templates) into .agents/skills/scikit-survival in your project. Codex loads it when a task matches its description.

Can I use scikit-survival Time-to-Event Modeling 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 davila7/claude-code-templates --skill scikit-survival -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/scikit-survival, .gemini/skills/scikit-survival, .github/skills/scikit-survival and .opencode/skills/scikit-survival in your project.

What does scikit-survival Time-to-Event Modeling need to run?

SKILL.md names no scripts, command-line tools or credentials: scikit-survival Time-to-Event Modeling is instructions for the agent only. Our summary lists: Python with `scikit-survival` and scikit-learn.

Does scikit-survival Time-to-Event Modeling access the network?

SKILL.md names 2 domains. As links in the text: scikit-survival.readthedocs.io and github.com. This is read from the text; nothing was executed.

Is scikit-survival Time-to-Event Modeling 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 scikit-survival Time-to-Event Modeling use?

scikit-survival Time-to-Event Modeling 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 scikit-survival Time-to-Event Modeling use?

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

What are the alternatives to scikit-survival Time-to-Event Modeling?

Skills that share tags, products or a category with scikit-survival Time-to-Event Modeling: Statistical Data Analysis (lingzhi227/agent-research-skills, 386 stars), Scikit Learn (zLanqing/codex-claude-academic-skills, 4.7k stars), Senior Data Scientist (Raidriar7170/hermes-skilleval, 125 stars) and Time Series Analytics User (open-edge-platform/edge-ai-libraries, 169 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains scikit-survival Time-to-Event Modeling?

davila7 (a GitHub user) maintains it in davila7/claude-code-templates, which has 32,483 GitHub stars. The repository holds 478 skills in this directory. The repository was last updated on October 9, 2026.

Source: davila7/claude-code-templates on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.