Skip to content

DAAF-Contribution-Community/daaf / .claude/skills/data-scientist

data-scientist

Verified

Data science methodology and method-selection routing for quantitative research. Covers EDA, data validation, descriptive analysis, causal inference (IV, DiD, RD, synthetic control), clustering/PCA/UMAP, supervised ML, geospatial analysis, network analysis, and visualization design. Contains the canonical method-to-library routing tree, routed by execution language — Python: statsmodels (OLS/GLM/time series), pyfixest (FE/IV/DiD), linearmodels (RE/GMM/SUR), svy (complex surveys), scikit-learn (clustering/prediction ML), geopandas (spatial), igraph (network analysis); R: r-stats (OLS/GLM/time series), fixest (FE/IV/DiD), plm (panel RE/between, dynamic GMM), survey-r (complex surveys), tidymodels (ML), sf-terra (spatial), igraph-r (network analysis). Load the routed tool-specific skill before giving tool-specific advice or writing code — library skills encode environment constraints and curated caveats absent from general knowledge.

references/eda-checklist.md

View on GitHub
# EDA Checklist

Detailed procedures for exploratory data analysis. Follow these checks BEFORE performing any analysis or transformation.

## Contents

- [Initial Data Inspection](#initial-data-inspection)
- [Missing Value Analysis](#missing-value-analysis)
- [Distribution Analysis](#distribution-analysis)
- [Outlier Detection](#outlier-detection)
- [Uniqueness and Cardinality](#uniqueness-and-cardinality)
- [Correlation Analysis](#correlation-analysis)
- [Automated Profiling Tools](#automated-profiling-tools)

## Initial Data Inspection

Run these checks immediately after loading ANY new dataset.

### Basic Shape and Structure

**Python:**
```python
import polars as pl
import polars.selectors as cs

# Load data
df = pl.read_parquet("data.parquet")

# Basic inspection
print(f"Shape: {df.shape[0]} rows x {df.shape[1]} columns")
print(f"Columns: {df.columns}")
print(f"Memory usage: {df.estimated_size() / 1024 / 1024:.2f} MB")
```

**R:**
```r
library(arrow)
library(dplyr)

# Load data
df <- read_parquet("data.parquet")

# Basic inspection
cat(sprintf("Shape: %d rows x %d columns\n", nrow(df), ncol(df)))
cat("Columns:", paste(names(df), collapse = ", "), "\n")
cat(sprintf("Memory usage: %.2f MB\n", object.size(df) / 1024 / 1024))
```

### Data Types

**Python:**
```python
# Check types - look for unexpected types
print("Data types:")
for col in df.columns:
    print(f"  {col}: {df[col].dtype}")

# Common issues to look for:
# - Dates stored as strings
# - Numbers stored as strings (often due to formatting or special values)
# - Mixed types (will show as Object/String)
```

**R:**
```r
# Check types - look for unexpected types
cat("Data types:\n")
for (col in names(df)) {
  cat(sprintf("  %s: %s\n", col, class(df[[col]])))
}

# Common issues to look for:
# - Dates stored as character
# - Numbers stored as character (often due to formatting or special values)
# - Mixed types (will show as character)
```

### Preview Data

**Python:**
```python
# Multiple views to catch different issues
print("First 5 rows:")
print(df.head())

print("\nLast 5 rows:")  # Often reveals truncation or footer issues
print(df.tail())

print("\nRandom sample:")  # Avoids bias from sorted data
print(df.sample(5, seed=42))
```

**R:**
```r
# Multiple views to catch different issues
cat("First 5 rows:\n")
print(head(df, 5))

cat("\nLast 5 rows:\n")  # Often reveals truncation or footer issues
print(tail(df, 5))

cat("\nRandom sample:\n")  # Avoids bias from sorted data
set.seed(42)
print(df |> slice_sample(n = 5))
```

### Column Name Issues

**Python:**
```python
# Check for problematic column names
for col in df.columns:
    issues = []
    if col != col.strip():
        issues.append("leading/trailing whitespace")
    if col != col.lower():
        issues.append("mixed case")
    if " " in col:
        issues.append("contains spaces")
    if issues:
        print(f"Column '{col}': {', '.join(issues)}")
```

**R:**
```r
# Check for problematic column names
for (col in names(df)) {
  issues <- c()
  if (col != trimws(col)) issues <- c(issues, "leading/trailing whitespace")
  if (col != tolower(col)) issues <- c(issues, "mixed case")
  if (grepl(" ", col)) issues <- c(issues, "contains spaces")
  if (length(issues) > 0) {
    cat(sprintf("Column '%s': %s\n", col, paste(issues, collapse = ", ")))
  }
}
```

## Missing Value Analysis

Understanding missingness patterns is CRITICAL. Different patterns require different handling.

### Count and Percentage

**Python:**
```python
# Missing value summary
null_counts = df.null_count()
null_pcts = (df.null_count() / len(df) * 100)

print("Missing values:")
for col in df.columns:
    count = null_counts[col].item()
    pct = null_pcts[col].item()
    if count > 0:
        print(f"  {col}: {count} ({pct:.1f}%)")
```

**R:**
```r
# Missing value summary
cat("Missing values:\n")
for (col in names(df)) {
  count <- sum(is.na(df[[col]]))
  pct <- count / nrow(df) * 100
  if (count > 0) {
    cat(sprintf("  %s: %d (%.1f%%)\n", col, count, pct))
  }
}
```

### Patterns of Missingness

Three types of missingness (important for handling strategy):

| Pattern | Description | Detection | Handling |
|---------|-------------|-----------|----------|
| **MCAR** | Missing Completely At Random | Missingness unrelated to any data | Safe to drop or impute |
| **MAR** | Missing At Random | Missingness depends on observed data | Impute using related columns |
| **MNAR** | Missing Not At Random | Missingness depends on unobserved data | Requires domain knowledge |

**Python:**
```python
# Visual inspection of missingness patterns
# Look for: columns that are always missing together

# Check if missingness correlates across columns
missing_cols = [col for col in df.columns if df[col].null_count() > 0]
if len(missing_cols) > 1:
    # Create missingness indicator DataFrame
    missing_indicators = df.select([
        pl.col(col).is_null().alias(f"{col}_missing")
        for col in missing_cols
    ])
    # Correlation of missingness patterns
    print("Missingness correlation (high = missing together):")
    print(missing_indicators.cast(pl.Int8).corr())
```

**R:**
```r
# Visual inspection of missingness patterns
# Look for: columns that are always missing together

# Check if missingness correlates across columns
missing_cols <- names(df)[sapply(df, \(x) any(is.na(x)))]
if (length(missing_cols) > 1) {
  # Create missingness indicator data frame
  missing_indicators <- df |>
    select(all_of(missing_cols)) |>
    mutate(across(everything(), is.na))
  # Correlation of missingness patterns
  cat("Missingness correlation (high = missing together):\n")
  print(cor(missing_indicators))
}
```

### Special Missing Value Codes

Data often uses special values instead of null:

**Python:**
```python
# Common special values to check for
special_values = ["", "N/A", "NA", "n/a", "null", "NULL", "None", "-", "--", ".", "?", "-999", "9999"]

for col in df.select(pl.col(pl.String)).columns:
    value_counts = df[col].value_counts()
    for sv in special_values:
        count = value_counts.filter(pl.col(col) == sv)
        if len(count) > 0:
            print(f"Column '{col}' has {count[0, 'count']} instances of '{sv}'")

# Numeric sentinel codes (e.g., -999; Education Data Portal -1/-2/-3) are invisible to the string scan
numeric_sentinels = [-1, -2, -3, -9, -99, -999, 9999]
for col in df.select(cs.numeric()).columns:
    counts = df.filter(pl.col(col).is_in(numeric_sentinels)).group_by(col).len()
    for value, count in counts.iter_rows():
        print(f"Column '{col}' has {count} instances of {value} (possible missing-value code)")
```

**R:**
```r
# Common special values to check for
special_values <- c("", "N/A", "NA", "n/a", "null", "NULL", "None", "-", "--", ".", "?", "-999", "9999")

char_cols <- names(df)[sapply(df, is.character)]
for (col in char_cols) {
  for (sv in special_values) {
    count <- sum(df[[col]] == sv, na.rm = TRUE)
    if (count > 0) {
      cat(sprintf("Column '%s' has %d instances of '%s'\n", col, count, sv))
    }
  }
}

# Numeric sentinel codes (e.g., -999; Education Data Portal -1/-2/-3) are invisible to the character scan
numeric_sentinels <- c(-1, -2, -3, -9, -99, -999, 9999)
num_cols <- names(df)[sapply(df, is.numeric)]
for (col in num_cols) {
  for (sv in numeric_sentinels) {
    count <- sum(df[[col]] == sv, na.rm = TRUE)
    if (count > 0) {
      cat(sprintf("Column '%s' has %d instances of %s (possible missing-value code)\n", col, count, sv))
    }
  }
}
```

## Distribution Analysis

### Numerical Columns

**Python:**
```python
# Summary statistics
print(df.describe())

# For each numerical column, check:
for col in df.select(cs.numeric()).columns:
    stats = df.select([
        pl.col(col).min().alias("min"),
        pl.col(col).quantile(0.25).alias("q25"),
        pl.col(col).median().alias("median"),
        pl.col(col).mean().alias("mean"),
        pl.col(col).quantile(0.75).alias("q75"),
        pl.col(col).max().alias("max"),
        pl.col(col).std().alias("std"),
        pl.col(col).skew().alias("skew"),
    ])
    print(f"\n{col}:")
    print(stats)
    
    # Red flags:
    # - Large difference between mean and median (skewness)
    # - Min or max far from quartiles (outliers)
    # - Std = 0 (constant column)
```

**R:**
```r
# Summary statistics
print(summary(df))

# For each numerical column, check:
num_cols <- names(df)[sapply(df, is.numeric)]
for (col in num_cols) {
  vals <- df[[col]]
  cat(sprintf("\n%s:\n", col))
  cat(sprintf("  min: %s, q25: %s, median: %s, mean: %s, q75: %s, max: %s, sd: %s, skew: %s\n",
              format(min(vals, na.rm = TRUE), big.mark = ","),
              format(quantile(vals, 0.25, na.rm = TRUE), big.mark = ","),
              format(median(vals, na.rm = TRUE), big.mark = ","),
              format(mean(vals, na.rm = TRUE), big.mark = ","),
              format(quantile(vals, 0.75, na.rm = TRUE), big.mark = ","),
              format(max(vals, na.rm = TRUE), big.mark = ","),
              format(sd(vals, na.rm = TRUE), big.mark = ","),
              format(e1071::skewness(vals, na.rm = TRUE, type = 1), digits = 3)))

  # Red flags:
  # - Large difference between mean and median (skewness)
  # - Min or max far from quartiles (outliers)
  # - Std = 0 (constant column)
}
```

### Categorical Columns

**Python:**
```python
# For each string/categorical column
for col in df.select(pl.col(pl.String)).columns:
    n_unique = df[col].n_unique()
    total = len(df)
    
    print(f"\n{col}:")
    print(f"  Unique values: {n_unique} ({n_unique/total*100:.1f}% of rows)")
    
    # Show top values
    print("  Top values:")
    print(df[col].value_counts().head(10))
    
    # Red flags:
    # - Very high cardinality (might be an ID column)
    # - Single value (constant column)
    # - Many low-frequency values (potential data quality issues)
```

**R:**
```r
# For each character/categorical column
char_cols <- names(df)[sapply(df, is.character)]
for (col in char_cols) {
  n_unique <- n_distinct(df[[col]])
  total <- nrow(df)

  cat(sprintf("\n%s:\n", col))
  cat(sprintf("  Unique values: %d (%.1f%% of rows)\n", n_unique, n_unique / total * 100))

  # Show top values
  cat("  Top values:\n")
  print(df |> count(.data[[col]], sort = TRUE) |> head(10))

  # Red flags:
  # - Very high cardinality (might be an ID column)
  # - Single value (constant column)
  # - Many low-frequency values (potential data quality issues)
}
```

### Date/Time Columns

**Python:**
```python
# For datetime columns
for col in df.select(cs.temporal()).columns:
    print(f"\n{col}:")
    print(f"  Min: {df[col].min()}")
    print(f"  Max: {df[col].max()}")
    print(f"  Range: {df[col].max() - df[col].min()}")
    
    # Check for gaps in time series
    # Check for future dates (often errors)
    # Check for very old dates (often errors)
```

**R:**
```r
# For date/datetime columns
date_cols <- names(df)[sapply(df, \(x) inherits(x, c("Date", "POSIXct", "POSIXlt")))]
for (col in date_cols) {
  cat(sprintf("\n%s:\n", col))
  cat(sprintf("  Min: %s\n", min(df[[col]], na.rm = TRUE)))
  cat(sprintf("  Max: %s\n", max(df[[col]], na.rm = TRUE)))
  cat(sprintf("  Range: %s\n", difftime(max(df[[col]], na.rm = TRUE),
                                         min(df[[col]], na.rm = TRUE))))

  # Check for gaps in time series
  # Check for future dates (often errors)
  # Check for very old dates (often errors)
}
```

## Outlier Detection

### IQR Method

**Python:**
```python
# Detect outliers using IQR method
q1 = df[col].quantile(0.25)
q3 = df[col].quantile(0.75)
iqr = q3 - q1
lower_bound = q1 - 1.5 * iqr
upper_bound = q3 + 1.5 * iqr
outliers = df.filter((pl.col(col) < lower_bound) | (pl.col(col) > upper_bound))
print(f"'{col}': IQR bounds [{lower_bound:.2f}, {upper_bound:.2f}], {len(outliers)} outliers ({len(outliers)/len(df)*100:.1f}%)")
```

**R:**
```r
# Detect outliers using IQR method
q1 <- quantile(df[[col]], 0.25, na.rm = TRUE)
q3 <- quantile(df[[col]], 0.75, na.rm = TRUE)
iqr_val <- q3 - q1
lower_bound <- q1 - 1.5 * iqr_val
upper_bound <- q3 + 1.5 * iqr_val
outliers <- df |> filter(.data[[col]] < lower_bound | .data[[col]] > upper_bound)
cat(sprintf("'%s': IQR bounds [%.2f, %.2f], %d outliers (%.1f%%)\n",
            col, lower_bound, upper_bound, nrow(outliers), nrow(outliers) / nrow(df) * 100))
```

### Z-Score Method

**Python:**
```python
# Detect outliers using z-score method
mean = df[col].mean()
std = df[col].std()
threshold = 3.0
outliers = df.filter(((pl.col(col) - mean) / std).abs() > threshold)
print(f"'{col}': mean={mean:.2f}, std={std:.2f}, {len(outliers)} outliers with |z| > {threshold} ({len(outliers)/len(df)*100:.1f}%)")
```

**R:**
```r
# Detect outliers using z-score method
col_mean <- mean(df[[col]], na.rm = TRUE)
col_sd <- sd(df[[col]], na.rm = TRUE)
threshold <- 3.0
outliers <- df |> filter(abs((.data[[col]] - col_mean) / col_sd) > threshold)
cat(sprintf("'%s': mean=%.2f, sd=%.2f, %d outliers with |z| > %.1f (%.1f%%)\n",
            col, col_mean, col_sd, nrow(outliers), threshold, nrow(outliers) / nrow(df) * 100))
```

### Important: Investigate Before Removing

**NEVER automatically remove outliers.** Always:
1. Examine outlier records in full
2. Understand WHY they're outliers
3. Consult domain experts if available
4. Document decision and rationale

**Python:**
```python
# Examine outliers in context (using IQR method from above)
if len(outliers) > 0:
    print("\nOutlier records (examine these!):")
    print(outliers.head(10))
```

**R:**
```r
# Examine outliers in context (using IQR method from above)
if (nrow(outliers) > 0) {
  cat("\nOutlier records (examine these!):\n")
  print(head(outliers, 10))
}
```

## Uniqueness and Cardinality

### Identifying Granularity

The most important question: **What does each row represent?**

**Python:**
```python
# Check if columns uniquely identify rows
unique_count = df.select(cols).n_unique()
is_unique = unique_count == len(df)
print(f"Columns {cols}: {unique_count:,} unique / {len(df):,} total → {'unique key' if is_unique else 'NOT unique'}")
```

**R:**
```r
# Check if columns uniquely identify rows
unique_count <- df |> distinct(across(all_of(cols))) |> nrow()
is_unique <- unique_count == nrow(df)
cat(sprintf("Columns [%s]: %s unique / %s total -> %s\n",
            paste(cols, collapse = ", "),
            format(unique_count, big.mark = ","), format(nrow(df), big.mark = ","),
            if (is_unique) "unique key" else "NOT unique"))
```

Test various candidate key combinations:

**Python:**
```python
for cols in [["id"], ["user_id"], ["user_id", "date"], ["user_id", "product_id", "timestamp"]]:
    unique_count = df.select(cols).n_unique()
    is_unique = unique_count == len(df)
    print(f"Columns {cols}: {unique_count:,} unique / {len(df):,} total → {'unique key' if is_unique else 'NOT unique'}")
```

**R:**
```r
candidate_keys <- list(c("id"), c("user_id"), c("user_id", "date"), c("user_id", "product_id", "timestamp"))
for (cols in candidate_keys) {
  unique_count <- df |> distinct(across(all_of(cols))) |> nrow()
  is_unique <- unique_count == nrow(df)
  cat(sprintf("Columns [%s]: %s unique / %s total -> %s\n",
              paste(cols, collapse = ", "),
              format(unique_count, big.mark = ","), format(nrow(df), big.mark = ","),
              if (is_unique) "unique key" else "NOT unique"))
}
```

### Duplicate Detection

**Python:**
```python
# Check for exact duplicate rows
n_duplicates = len(df) - len(df.unique())
print(f"Exact duplicate rows: {n_duplicates}")

# If duplicates exist, examine them
if n_duplicates > 0:
    # Find duplicate rows
    dup_counts = df.group_by(df.columns).len().filter(pl.col("len") > 1)
    print(f"\nDuplicate patterns ({len(dup_counts)} groups):")
    print(dup_counts.head(10))
```

**R:**
```r
# Check for exact duplicate rows
n_duplicates <- nrow(df) - nrow(distinct(df))
cat(sprintf("Exact duplicate rows: %d\n", n_duplicates))

# If duplicates exist, examine them
if (n_duplicates > 0) {
  dup_counts <- df |> group_by(across(everything())) |> summarise(n = n(), .groups = "drop") |> filter(n > 1)
  cat(sprintf("\nDuplicate patterns (%d groups):\n", nrow(dup_counts)))
  print(head(dup_counts, 10))
}
```

### Cardinality Analysis

| Cardinality Level | Typical Use | Example |
|-------------------|-------------|---------|
| 1 (constant) | Often useless, remove | All values are "USA" |
| Very low (2-10) | Binary/categorical | Gender, Status |
| Low (10-100) | Categorical | Category, Region |
| Medium (100-10k) | High-cardinality categorical | City, Product |
| High (>10k or unique) | ID column or free text | User ID, Comments |

**Python:**
```python
# Cardinality summary
print("Cardinality analysis:")
for col in df.columns:
    n_unique = df[col].n_unique()
    pct_unique = n_unique / len(df) * 100
    
    if n_unique == 1:
        category = "CONSTANT (consider removing)"
    elif n_unique == 2:
        category = "Binary"
    elif n_unique <= 10:
        category = "Low cardinality"
    elif n_unique <= 100:
        category = "Medium cardinality"
    elif pct_unique > 90:
        category = "HIGH (possible ID column)"
    else:
        category = "High cardinality"
    
    print(f"  {col}: {n_unique} unique ({pct_unique:.1f}%) - {category}")
```

**R:**
```r
# Cardinality summary
cat("Cardinality analysis:\n")
for (col in names(df)) {
  n_unique <- n_distinct(df[[col]])
  pct_unique <- n_unique / nrow(df) * 100

  category <- if (n_unique == 1) {
    "CONSTANT (consider removing)"
  } else if (n_unique == 2) {
    "Binary"
  } else if (n_unique <= 10) {
    "Low cardinality"
  } else if (n_unique <= 100) {
    "Medium cardinality"
  } else if (pct_unique > 90) {
    "HIGH (possible ID column)"
  } else {
    "High cardinality"
  }

  cat(sprintf("  %s: %d unique (%.1f%%) - %s\n", col, n_unique, pct_unique, category))
}
```

## Correlation Analysis

### Numerical Correlations

**Python:**
```python
# Pearson correlation for numerical columns
numeric_cols = df.select(cs.numeric()).columns
if len(numeric_cols) > 1:
    # Polars correlation
    corr_matrix = df.select(numeric_cols).drop_nulls().corr()  # complete cases; any null gives NaN
    print("Correlation matrix:")
    print(corr_matrix)
    
    # Flag high correlations (potential multicollinearity)
    # Threshold typically 0.7-0.9
    threshold = 0.7
    print(f"\nHighly correlated pairs (|r| > {threshold}):")
    # ... extract pairs above threshold
```

**R:**
```r
# Pearson correlation for numerical columns
num_cols <- names(df)[sapply(df, is.numeric)]
if (length(num_cols) > 1) {
  corr_matrix <- cor(df |> select(all_of(num_cols)), use = "pairwise.complete.obs")
  cat("Correlation matrix:\n")
  print(round(corr_matrix, 3))

  # Flag high correlations (potential multicollinearity)
  threshold <- 0.7
  cat(sprintf("\nHighly correlated pairs (|r| > %.1f):\n", threshold))
  # Extract upper triangle pairs above threshold
  for (i in seq_len(ncol(corr_matrix) - 1)) {
    for (j in (i + 1):ncol(corr_matrix)) {
      if (abs(corr_matrix[i, j]) > threshold) {
        cat(sprintf("  %s - %s: %.3f\n", num_cols[i], num_cols[j], corr_matrix[i, j]))
      }
    }
  }
}
```

### Categorical Associations

For categorical columns, examine cross-tabulations:

**Python:**
```python
# Cross-tabulation
ct = df.group_by([col1, col2]).len().pivot(on=col2, index=col1, values="len").fill_null(0)
print(ct)
```

**R:**
```r
# Cross-tabulation
ct <- table(df[[col1]], df[[col2]])
print(ct)
```

## Automated Profiling Tools

For comprehensive automated profiling:

### ydata-profiling (formerly pandas-profiling)

**Python:**
```python
# ydata-profiling is NOT pre-installed; runtime installs are blocked -- add it to
# the Dockerfile (user additions block) and rebuild before use (see CLAUDE.md
# § Runtime Package Installation)
from ydata_profiling import ProfileReport

# Note: Requires pandas DataFrame
profile = ProfileReport(df.to_pandas(), title="Data Profile", explorative=True)
profile.to_file("data_profile.html")

# For large datasets, use minimal mode
profile = ProfileReport(df.to_pandas(), minimal=True)
```

**R:**
```r
# skimr is pre-installed in DAAF -- no install needed (runtime installs are blocked)
library(skimr)

# skimr provides a comprehensive profiling summary
skim(df)

# For HTML report output, use DataExplorer -- NOT pre-installed; runtime installs
# are blocked, so add it to the Dockerfile (user additions block) and rebuild
# before use (see CLAUDE.md § Runtime Package Installation), then:
# DataExplorer::create_report(df, output_file = "data_profile.html")
```

### Manual Profiling Summary

If automated tools unavailable, generate this summary:

**Python:**
```python
# Generate a quick profile summary
print(f"Shape: {df.shape}")
print(f"Columns: {df.columns}")
for col in df.columns:
    dtype = df[col].dtype
    nulls = df[col].null_count()
    uniques = df[col].n_unique()
    print(f"  {col}: {dtype}, {nulls} nulls, {uniques} unique")
print(f"\nNumeric summary:\n{df.select(cs.numeric()).describe()}")
```

**R:**
```r
# Generate a quick profile summary
cat(sprintf("Shape: %d x %d\n", nrow(df), ncol(df)))
cat("Columns:", paste(names(df), collapse = ", "), "\n")
for (col in names(df)) {
  dtype <- class(df[[col]])
  nulls <- sum(is.na(df[[col]]))
  uniques <- n_distinct(df[[col]])
  cat(sprintf("  %s: %s, %d NAs, %d unique\n", col, dtype, nulls, uniques))
}
cat("\nNumeric summary:\n")
print(summary(df |> select(where(is.numeric))))
```

## Red Flags Checklist

After completing EDA, check for these red flags:

- [ ] **High missingness** (>10%) in critical columns
- [ ] **Unexpected data types** (dates as strings, numbers as strings)
- [ ] **Constant columns** (only one unique value)
- [ ] **Near-constant columns** (one value dominates 99%+)
- [ ] **Unexpected duplicates** (should be unique but isn't)
- [ ] **Extreme outliers** (values orders of magnitude different)
- [ ] **Future dates** (often data entry errors)
- [ ] **Negative values** where only positive expected
- [ ] **High cardinality** where low expected (possible ID column mixed in)
- [ ] **Low cardinality** where high expected (possible data truncation)
- [ ] **Suspicious value distributions** (too perfect, too uniform)
- [ ] **Inconsistent encodings** (same thing represented differently)
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall