Agent skill · Data & Analytics

ds-roast

Deep technical review of data science, MLOps, and machine learning projects. No feelings attached — pure roast mode. Surfaces bugs, modeling issues, leakage, bad practices, and improvement opportunities.

majiayu000github.com/majiayu000GitHub ↗
claude-codeMIT
Install
npx skills add majiayu000/claude-skill-registry --skill ds-roast --agent claude-code

Same command for any agent — swap --agent for codex, cursor, copilot.

Facts
Files in the skill folder: 2
SKILL.md size: 27 KB
Bundled scripts: none
Path: skills/analysis/ds-roast/SKILL.md
Open the folder on GitHub →
Where it comes from
Stars: 534
Language: HTML

Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.

Review
written from the skill's own SKILL.md · Aug 5, 2026

What it does

The skill directs the agent to act as a ruthless senior ML engineer performing a deep, exhaustive codebase review of data science, MLOps, and ML projects. It prescribes identifying anti-patterns, data leakage, data quality problems, modeling pitfalls, evaluation and baselines shortcomings, time-series pitfalls, and reproducibility gaps, then providing concrete, actionable fixes for each issue.

How it works

Step 1: Codebase Reconnaissance — Thoroughly explore the repository structure and relevant files, mapping layout, presence of notebooks, pyproject/requirements, configs, data files, tests, and any indication of testing or CI pipelines. Step 1 also analyzes the data pipeline by locating data loading, preprocessing, and feature engineering, tracing data flow from raw sources to model input, distinguishing train-time from inference-time transformations, and inspecting any aggregated features for potential leakage. It reviews lag depths and timing relative to the prediction point. Step 1 continues with Modeling — locating model definitions, training loops, hyperparameters, and evaluation code to confirm problem type and loss/metrics alignment. It assesses MLOps posture including experiment tracking, reproducibility, model versioning, artifacts, serving infrastructure, and CI/CD. Step 1 ends with Testing — checking for unit, data validation, integration, and property-based tests.

Step 2: The Roast — Structured Technical Review — delivers findings in mandatory sections with:

  • Location: file and line number where issues are found.
  • The Problem: exact technical description.
  • Why It Matters: concrete downstream impact.
  • Fix: specific, actionable code-level recommendations.

The roast categorizes issues into:

  • 🔴 Critical Issues — Data Leakage and Data Quality, plus Other Critical Issues like wrong loss, NaN propagation, and serialization bugs.
  • 🟠 Modeling & Methodology Issues — Evaluation, Baselines, Feature Engineering, Modeling Choices, Time-Series specifics.
  • 🟡 MLOps & Reproducibility Gaps — Reproducibility practices and environment pinning.

It emphasizes preventing leakage (preprocessing, target, temporal, group, etc.), ensuring proper train/val/test separations, correct lagging, and strict sequencing of data processing relative to prediction windows. It also enforces explicit schema handling, proper handling of unknown categories, and robust evaluation protocols.

When to use it

Use this skill when you want an in-depth, production-focused technical critique of a DS/ML project, particularly to surface leakage, data quality issues, improper feature engineering, modeling flaws, evaluation pitfalls, and MLOps gaps. It expects explicit file/line locations and concrete fixes, and it avoids high-level praise without actionable content.

What it can touch

  • Tools: claude-code
  • It asks to reference file paths, code constructs, and feature engineering patterns exactly as they appear in the repository when pinpointing issues and suggesting fixes.
  • It requires providing concrete, code-level suggestions (e.g., replace a calculation with a lagged version, wrap a feature inside a Pipeline, or move a split to TimeSeriesSplit).

Caveats

  • Licensing: MIT (as declared).
  • The analysis should be strictly based on the content and instructions within the skill’s own described process; no external assumptions beyond what is explicitly described in the guidance.
  • The review will not promise outcomes beyond what is stated in the ROAST guidelines (e.g., it will not claim fixes will solve all issues without implementing them).
From the SKILL.md

# DS/ML Technical Roast You are a ruthlessly honest, senior ML engineer and data scientist performing a deep technical code review. No compliments, no softening — just precise, specific, technical criticism and concrete suggestions for improvement. **Persona**: You have seen every anti-pattern in the book. You know what production ML looks like versus what notebooks-shoved-into-prod look like. You call things what they are. --- ## Step 1: Codebase Reconnaissance Before writing a single word of the review, do a thorough exploration of every relevant file. Be exhaustive. **Repository structure** - Map the full directory layout. Flag: flat structures, everything-in-one-notebook, no `src/` layout, no separation of concerns. - Look for: `*.ipynb`, `*.py`, `pyproject.toml`, `requirements.txt`, `Makefile`, `Dockerfile`, `dvc.yaml`, `mlflow`, `*.yaml`/`*.toml` configs, `*.sql`, `*.parquet`, `*.csv`. - Check for test directories (`tests/`, `test_*.py`). If absent, note it explicitly. **Data pipeline** - Locate data loading, preprocessing, and feature engineering code. - Trace the full data flow from raw source to model input. - Map which transformations happen at train time vs. inference ti

What's inside
Steps it walks through
  1. Step 1: Codebase Reconnaissance
  2. Step 2: The Roast — Structured Technical Review
  3. 🔴 Critical Issues — Will Burn You in Production
  4. 🟠 Modeling & Methodology Issues
  5. 🟡 MLOps & Reproducibility Gaps
  6. 🟢 Code Quality & Engineering
  7. 💀 The Hall of Shame
  8. Step 3: What Good Looks Like (Reference Checklist)
  9. Step 4: Prioritized Action Plan
  10. Step 5: Verdict
  11. Tone Rules
Ships with 1 file
  • metadata.json
More from claude-skill-registry
All skills →
About this skill
What does the ds-roast skill do?

Deep technical review of data science, MLOps, and machine learning projects. No feelings attached — pure roast mode. Surfaces bugs, modeling issues, leakage, bad practices, and improvement opportunities.

How do I install it?

Run `npx skills add majiayu000/claude-skill-registry --skill ds-roast --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.

Where does this skill come from?

From majiayu000/claude-skill-registry, a repository with 534 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.

Is a popular skill a good skill?

Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.

Keep going