data-analytics-skills-claude

# Data Analytics Skills for Claude > Skill by [ara.so](https://ara.so) — Data Skills collection. A structured library of 31 reusable AI-powered skills that turn Claude into a hands-on analytics partner. Each skill is a self-contained instruction set that works on-demand without setup, asking targeted questions to gather exactly what it needs before executing a complete analytical workflow. ## What This Project Does This is a **skill collection**, not a library you import. When you describe an analytics task, Claude automatically selects and activates the appropriate skill from six categories: 1. **Data Quality & Validation** (5 skills) - EDA, quality audits, query validation, schema mapping 2. **Documentation & Knowledge** (5 skills) - Semantic models, documentation, SQL translation 3. **Data Analysis & Investigation** (7 skills) - Cohorts, segmentation, funnels, time series, A/B tests 4. **Data Storytelling & Visualization** (5 skills) - Insights, charts, dashboards, narratives 5. **Stakeholder Communication** (5 skills) - Translation, requirements, impact quantification 6. **Workflow Optimization** (4 skills) - Planning, context packaging, peer review ## Installation ### For Individual Use 1. Clone the repository: ```bash git clone https://github.com/nimrodfisher/data-analytics-skills.git cd data-analytics-skills ``` 2. Reference skills in your Claude conversations: ``` "Use the programmatic-eda skill to analyze this dataset" ``` ### For AI Coding Agents Add to your agent's system prompt or project context: ```python # In your agent configuration SKILL_PATH = "./data-analytics-skills" # Reference specific skills with open(f"{SKILL_PATH}/01-data-quality-validation/programmatic-eda/SKILL.md") as f: skill_context = f.read() ``` ### For Teams Create a central repository with customized skills: ```bash # Fork and customize git clone https://github.com/your-org/data-analytics-skills.git cd data-analytics-skills # Add company-specific context mkdir -p 01-data-quality-validation/programmatic-eda/references echo "# Company Schema" > references/company-schema.md ``` ## Key Concepts ### Skill Structure Every skill follows this pattern: ``` skill-name/ ├── SKILL.md # Complete skill instructions ├── README.md # Human-readable documentation └── references/ # Optional: company-specific context ├── company-schema.md ├── metric-definitions.md └── business-rules.md ``` ### How Skills Work 1. **Minimal Context Request** - Skill asks only essential information 2. **Structured Execution** - Step-by-step analytical workflow 3. **Assumption Surfacing** - Flags uncertainties explicitly 4. **Templated Output** - Consistent, shareable results ## Common Usage Patterns ### Pattern 1: Exploratory Data Analysis ```python # You provide data import pandas as pd df = pd.read_csv('user_data.csv') print(df.head()) print(df.info()) # Then say: # "Run programmatic-eda on this dataset" # Claude will: # 1. Ask about business context # 2. Check data quality systematically # 3. Identify patterns, outliers, distributions # 4. Flag potential issues # 5. Suggest next analysis steps ``` ### Pattern 2: Root Cause Investigation ```python # You have a metric drop """ Our daily active users dropped from 10,000 to 8,800 last week. Activate root-cause-investigation. """ # Claude asks: # - Metric definition # - Normal baseline/range # - Recent changes # - Segmentation dimensions # Then provides: # 1. Hypothesis tree # 2. Data checks to run # 3. Segmentation analysis # 4. Timeline correlation # 5. Likely root causes ranked ``` ### Pattern 3: A/B Test Analysis ```python import pandas as pd import numpy as np # Load experiment data test_data = pd.DataFrame({ 'user_id': range(1000), 'variant': np.random.choice(['control', 'treatment'], 1000), 'converted': np.random.binomial(1, 0.15, 1000) }) # Say: "Analyze this A/B test with ab-test-analysis skill" # Claude will: # 1. Validate sample sizes # 2. Check for bias (SRM test) # 3. Calculate statistical significance # 4. Compute confidence intervals # 5. Assess practical significance # 6. Flag any issues ``` ### Pattern 4: SQL Documentation ```sql -- Complex query you need to explain SELECT DATE_TRUNC('week', u.created_at) AS cohort_week, COUNT(DISTINCT u.user_id) AS cohort_size, COUNT(DISTINCT CASE WHEN o.created_at <= u.created_at + INTERVAL '7 days' THEN o.user_id END) AS week_1_retained FROM users u LEFT JOIN orders o ON u.user_id = o.user_id WHERE u.created_at >= '2024-01-01' GROUP BY 1 ORDER BY 1; ``` Say: "Use sql-to-business-logic to document this query" Claude produces: - Plain English explanation - Business logic breakdown - Key assumptions - Edge cases handled - When to use/not use ### Pattern 5: Dashboard Specification ``` "I need a dashboard for marketing performance. Use dashboard-specification skill." ``` Claude asks about: - Primary audience - Key questions to answer - Available data sources - Refresh frequency needs Then delivers: - Metric definitions - Visual layout mockup - Filter specifications - Data requirements - Success criteria ### Pattern 6: Chaining Multiple Skills ```python # Full analysis workflow # 1. Planning phase """ Use analysis-planning for investigating signup drop. Context: B2C SaaS, 15% drop in weekly signups over 2 weeks. """ # 2. Data quality check """ Run data-quality-audit on signup table. [Provide schema and sample data] """ # 3. Investigation """ Execute root-cause-investigation with validated data. """ # 4. Documentation """ Use analysis-documentation to document findings. """ # 5. Stakeholder communication """ Generate executive-summary for VP of Growth. """ ``` ## Customization ### Adding Company Context Create a `references/` folder in any skill: ```bash cd 02-documentation-knowledge/semantic-model-builder mkdir references # Add your definitions cat > references/metric-definitions.md << 'EOF' # Standard Metrics ## Activation Rate - **Formula**: (Users completing 3+ key actions in 7 days) / Total signups - **Threshold**: >40% is healthy - **Owner**: Growth team ## Monthly Recurring Revenue (MRR) - **Formula**: Sum of all active subscription values - **Excludes**: One-time payments, paused subscriptions - **Currency**: USD normalized EOF ``` Claude automatically uses these references when the skill runs. ### Creating Team Conventions ```bash # Add analysis standards cat > 06-workflow-optimization/analysis-planning/references/team-conventions.md << 'EOF' # Analysis Standards ## Before Starting - [ ] Create JIRA ticket - [ ] Check if similar analysis exists - [ ] Schedule 15min scoping with PM ## During Analysis - [ ] Log all assumptions in analysis-assumptions-log - [ ] Validate data with data-quality-audit - [ ] Document queries in SQL comments ## Before Sharing - [ ] Run analysis-qa-checklist - [ ] Peer review with another analyst - [ ] Add to company wiki EOF ``` ## Skill Quick Reference ### When to Use Each Category | You Need To... | Category | Start With | |---------------|----------|------------| | Check new data quality | Data Quality | `programmatic-eda` | | Review or write SQL | Data Quality | `query-validation`, `schema-mapper` | | Investigate metric change | Analysis | `root-cause-investigation` | | Analyze customer behavior | Analysis | `cohort-analysis`, `segmentation-analysis` | | Measure experiment | Analysis | `ab-test-analysis` | | Document findings | Documentation | `analysis-documentation` | | Define metrics once | Documentation | `semantic-model-builder` | | Build dashboard | Storytelling | `dashboard-specification`, `visualization-builder` | | Present to executives | Stakeholder | `executive-summary-generator` | | Gather requirements | Stakeholder | `stakeholder-requirements-gathering` | | Plan complex analysis | Workflow | `analysis-planning` | ### Most Frequently Used Skills ```python # Top 10 by typical usage CORE_SKILLS = [ "programmatic-eda", # Start of every analysis "root-cause-investigation", # Metric drops/spikes "analysis-planning", # Before big projects "query-validation", # SQL review "semantic-model-builder", # One-time setup, huge ROI "ab-test-analysis", # Experiments "cohort-analysis", # Retention tracking "executive-summary-generator", # Reporting up "visualization-builder", # Chart decisions "analysis-documentation" # Knowledge capture ] ``` ## Troubleshooting ### Issue: Skill asks too many questions **Solution**: Provide more upfront context ```python # Instead of: "Analyze this data" # Do: """ Run programmatic-eda on user signup data. Context: - Table: signups - Rows: 50,000 - Timeframe: Last 90 days - Business: B2C SaaS - Main concerns: Conversion rate, signup source quality """ ``` ### Issue: Output doesn't match company standards **Solution**: Add company references ```bash cd skill-name/references # Create markdown files with your standards # Claude will automatically use them ``` ### Issue: Skill produces generic insights **Solution**: Provide business context explicitly ```python # Good context example: """ Use root-cause-investigation. Metric: Daily Active Users (DAU) - Normal range: 8,000-10,000 - Current: 6,500 (35% below normal) - Started: March 15 (5 days ago) - Recent changes: - New onboarding flow deployed March 14 - Email provider switched March 10 - Major competitor launched promo March 12 - Segments to check: Platform (iOS/Android/Web), User cohort, Geography """ ``` ### Issue: Want to use skills programmatically **Solution**: Reference skills in system prompts ```python import os def load_skill(skill_path): """Load skill content for programmatic use.""" with open(f"{skill_path}/SKILL.md", 'r') as f: return f.read() # Example: Build custom analysis pipeline skills = [ load_skill("01-data-quality-validation/data-quality-audit"), load_skill("03-data-analysis-investigation/cohort-analysis"), load_skill("04-data-storytelling-visualization/insight-synthesis") ] system_prompt = f""" You are a data analyst. Use these skills in sequence: {chr(10).join(skills)} Follow each skill's workflow completely before moving to the next. """ ``` ### Issue: Skills not activating automatically **Solution**: Skills activate based on natural language. Be explicit: ```python # Explicit activation: "Use the cohort-analysis skill to..." "Activate root-cause-investigation for..." "Run programmatic-eda on..." # Or describe the task clearly: "I need to understand retention by signup cohort" # → cohort-analysis "Why did our conversion rate drop?" # → root-cause-investigation "Check if this dataset is clean" # → data-quality-audit ``` ## Real-World Examples ### Example 1: Complete Investigation Workflow ```python """ PROJECT: Investigate 20% drop in mobile app engagement STEP 1: Plan the investigation → Use analysis-planning skill Output: Structured approach with hypotheses STEP 2: Validate data quality → Use data-quality-audit on app_events table Output: Quality report, issues flagged STEP 3: Run investigation → Use root-cause-investigation Output: Ranked hypotheses with evidence STEP 4: Deep dive on top cause → Use segmentation-analysis on iOS vs Android Output: iOS users affected, Android stable STEP 5: Document findings → Use analysis-documentation Output: Reproducible methodology doc STEP 6: Present to stakeholders → Use executive-summary-generator Output: 1-page summary for leadership """ ``` ### Example 2: Building a Metrics Framework ```python """ PROJECT: Create company-wide metric definitions STEP 1: Build semantic model → Use semantic-model-builder skill Provide: - List of key metrics (ARR, MRR, CAC, LTV, Churn, etc.) - Business definitions - Owners Output: Standardized metric layer STEP 2: Add to each relevant skill → Save output to references/metric-definitions.md in: - business-metrics-calculator/references/ - ab-test-analysis/references/ - executive-summary-generator/references/ STEP 3: Create data catalog → Use data-catalog-entry for each data source Result: Everyone uses same definitions automatically """ ``` ## Configuration ### Environment Variables No environment variables required. Skills work with data you provide in conversation. ### Optional: Team Configuration Create a `.data-skills-config.json` in your project root: ```json { "default_references_path": "./company-context", "metric_definitions": "./company-context/metrics.md", "schema_docs": "./company-context/schema.md", "business_rules": "./company-context/rules.md", "team_conventions": "./company-context/conventions.md" } ``` Reference in skills with: ``` See ${project_root}/.data-skills-config.json for company standards ``` ## Advanced Patterns ### Pattern: Automated Quality Gates ```python # Pre-commit hook for analysis files """ Before committing analysis: 1. Run analysis-qa-checklist 2. Verify all assumptions logged with analysis-assumptions-log 3. Check documentation exists via analysis-documentation 4. Validate SQL with query-validation """ ```