20 Claude Prompts for Data Analysis That Replace Hours of Spreadsheet Work

<context> Spreadsheet tool: [Excel / Google Sheets] Data layout: [describe your columns, e.g. "Column A = dates, B = product names, C = revenue, D = region"] Current row count: [approximate number of rows] Skill level: [beginner / intermediate / advanced] </context> <task> I need a formula that does the following: [DESCRIBE WHAT YOU WANT THE FORMULA TO DO — e.g. "Sum revenue for Product X in Q1 2026, but only for the East region, and show $0 if no data exists"] Provide: 1. The exact formula I can paste into cell [TARGET CELL] 2. A plain-English breakdown of what each part of the formula does 3. How to modify it if my column layout changes 4. A simpler alternative if one exists </task> <constraints> - Use only functions available in [Excel / Google Sheets] - Prefer XLOOKUP over VLOOKUP, FILTER over helper columns - If the formula exceeds 100 characters, break it into named ranges or helper columns and explain why - Handle edge cases: empty cells, text-in-number-columns, #N/A errors - Wrap in IFERROR with a meaningful fallback, not just 0 </constraints>

<context> Tool: [Excel / Google Sheets] Dataset: [describe your data — e.g. "12 months of sales transactions with columns: Date, Salesperson, Product, Region, Amount, Quantity"] Row count: [approximate] Goal: [what question you want the pivot table to answer] </context> <task> Design a pivot table configuration to answer: "[YOUR QUESTION — e.g. Which salesperson has the highest average deal size by region?]" Provide: 1. Rows, Columns, Values, and Filters — exactly what to drag where 2. Value field settings (Sum vs. Average vs. Count, and why) 3. Any calculated fields I should add 4. Recommended sort order and top-N filtering 5. A second pivot table layout if the data tells a richer story with a different angle </task> <constraints> - Assume I know how to create a pivot table but not how to configure it optimally - If the question requires multiple pivot tables, say so and design each one - Recommend slicers or timelines if they'd make the analysis interactive - Flag if my data needs cleaning before the pivot table will work correctly </constraints>

<context> Tool: [Excel / Google Sheets] Problem columns: [list columns that need cleaning — e.g. "Column B has mixed date formats, Column D has inconsistent company names, Column F has numbers stored as text"] Row count: [approximate] Deadline pressure: [I need this done in minutes / I can spend an hour] </context> <task> Create a step-by-step cleanup plan for my spreadsheet: For each problem column, provide: 1. A formula-based fix I can apply in a helper column (no VBA unless I ask) 2. The exact formula with cell references assuming data starts in row 2 3. Find-and-replace patterns for bulk fixes 4. A validation check to confirm the cleanup worked (e.g. COUNTIF for remaining issues) 5. Instructions to paste-values and remove helper columns when done Common issues to address: - Leading/trailing spaces - Inconsistent capitalization - Mixed date formats - Numbers stored as text - Duplicate variations of the same entity (e.g. "IBM" vs "I.B.M." vs "International Business Machines") </task> <constraints> - Formulas only — no macros unless the dataset exceeds 50K rows - Preserve original data in a backup sheet first - Each step must be reversible - If entity matching requires fuzzy logic, provide a VLOOKUP + helper table approach </constraints>

<context> Excel version: [Excel 365 / 2021 / 2019 / Google Apps Script] Task frequency: [one-time / daily / weekly / triggered by event] Current manual process: [describe what you do by hand — e.g. "Every Monday I open 4 regional CSV files, consolidate into one sheet, add a pivot table, and email the summary to my manager"] VBA experience: [none / can edit existing macros / comfortable writing macros] </context> <task> Write a VBA macro (or Google Apps Script) that automates this process: [DESCRIBE THE FULL WORKFLOW TO AUTOMATE] Requirements: 1. Complete, runnable code with comments explaining each section 2. Error handling — what happens if a file is missing, a sheet doesn't exist, or data is empty 3. A status message or log so I know what the macro did 4. Instructions for where to paste the code and how to run it 5. How to assign it to a button or keyboard shortcut </task> <constraints> - Code must be copy-paste ready — no placeholder functions - Use early binding for known libraries, late binding if the user might not have references set - Add a confirmation dialog before any destructive action (deleting sheets, overwriting data) - If the task involves email, use Outlook object model (not CDO) - Keep the code under 150 lines — break into sub-procedures if longer - Add a comment header with: purpose, author, date, and instructions </constraints>

<context> Database: [PostgreSQL / MySQL / SQL Server / SQLite / BigQuery] Tables involved: [list tables with key columns — e.g. "orders(id, customer_id, amount, created_at, status), customers(id, name, email, region, signup_date)"] Relationships: [e.g. "orders.customer_id -> customers.id"] Data volume: [approximate row counts per table] </context> <task> Write a SQL query that answers this question: "[YOUR QUESTION IN PLAIN ENGLISH — e.g. Show me the top 10 customers by total spend in the last 90 days who haven't placed an order in the last 30 days]" Provide: 1. The complete query, formatted and commented 2. Expected output columns and what each represents 3. Any assumptions you made about the data 4. Performance notes if the query touches large tables 5. How to modify the query for common variations (different date ranges, additional filters) </task> <constraints> - Use syntax specific to [DATABASE TYPE] - Use CTEs over subqueries for readability when nesting exceeds 2 levels - Include appropriate indexes to suggest if the query is slow - Handle NULLs explicitly — don't let them silently distort results - If the question is ambiguous, state the assumption and provide both interpretations - Add comments for any non-obvious logic </constraints>

<context> Database: [PostgreSQL / MySQL / SQL Server / BigQuery] Table sizes: [list tables and approximate row counts] Current indexes: [list existing indexes, or say "unknown"] Query execution time: [current runtime — e.g. "takes 45 seconds"] Target execution time: [acceptable runtime — e.g. "under 2 seconds"] </context> <task> Optimize this slow query: [PASTE YOUR SLOW SQL QUERY] Provide: 1. Why it's slow — the specific bottleneck (full table scan, missing index, correlated subquery, etc.) 2. The optimized query with changes highlighted in comments 3. Indexes to create (with exact CREATE INDEX statements) 4. EXPLAIN plan interpretation — what to look for to confirm the fix worked 5. Alternative approaches if the optimization still isn't enough (materialized views, denormalization, caching) </task> <constraints> - Don't change the business logic — the optimized query must return identical results - If you suggest an index, estimate the storage cost and write impact - Prefer query restructuring over index creation when both solve the problem - If the query can't be optimized further, explain why and suggest architectural alternatives - Include the EXPLAIN ANALYZE command to run before and after </constraints>

<context> My SQL skill level: [beginner / intermediate / advanced] Database: [PostgreSQL / MySQL / SQL Server / other] Context: [why I'm reading this query — e.g. "inherited codebase", "debugging a report", "reviewing a PR"] </context> <task> Explain this SQL query in plain English: [PASTE THE SQL QUERY] Provide: 1. One-sentence summary: what this query does in business terms 2. Step-by-step walkthrough — what each clause does, in the order the database executes them (FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY -> LIMIT) 3. A visual diagram of how the tables join (text-based) 4. Edge cases — what data scenarios might produce unexpected results 5. If this query has bugs or inefficiencies, flag them </task> <constraints> - Explain at my stated skill level — [beginner: no jargon / intermediate: use standard terms / advanced: focus on execution plan implications] - Don't just translate syntax — explain the "why" behind each clause - If window functions are used, explain the partitioning and ordering in plain language - Highlight any parts that are unnecessarily complex and suggest simpler alternatives </constraints>

<context> Source database: [type, version, and relevant schema] Target database: [type, version] Migration scope: [full database / specific tables / schema only / data only] Downtime tolerance: [zero downtime required / maintenance window of X hours / flexible] Data volume: [approximate total size] </context> <task> Create a migration plan from [SOURCE] to [TARGET]: 1. Schema conversion — DDL statements for the target database, handling type differences 2. Data migration — INSERT/COPY scripts or ETL approach 3. Sequence/auto-increment handling 4. Foreign key and constraint recreation order 5. Index recreation 6. Stored procedures / views / triggers that need rewriting 7. Validation queries — how to confirm row counts and data integrity match 8. Rollback plan — how to revert if something goes wrong </task> <constraints> - Handle data type incompatibilities explicitly (e.g. MySQL ENUM to PostgreSQL, SQL Server IDENTITY to PostgreSQL SERIAL) - Migration scripts must be idempotent — safe to re-run - Include transaction boundaries for data safety - Flag any features in the source that have no direct equivalent in the target - Provide estimated migration time based on stated data volume - Test queries should compare checksums, not just row counts </constraints>

<context> Data source: [CSV file / database table / spreadsheet] Record count: [approximate] Key columns for matching: [e.g. "name, email, phone, address"] Known duplicate patterns: [e.g. "same person with different email addresses", "company name variations like LLC vs L.L.C."] Tool preference: [Excel formulas / Python pandas / SQL / any] </context> <task> Build a deduplication strategy for my dataset: 1. Exact match pass — identify rows that are identical on [KEY COLUMNS] 2. Fuzzy match pass — catch near-duplicates using: - Name variations (Bob/Robert, Inc/Incorporated) - Typos (Levenshtein distance threshold) - Phone/email normalization 3. Merge rules — when duplicates are found, which record wins? (most recent, most complete, specific source priority) 4. The complete code/formulas to execute this 5. A report showing: total records, duplicates found, records after dedup, confidence scores </task> <constraints> - Preserve all original data in a backup before any dedup - Assign a confidence score to each match: Definite (100%), Likely (80%+), Review (60-80%) - "Review" matches should be flagged for human decision, not auto-merged - If using Python, use only pandas and fuzzywuzzy/rapidfuzz (no paid APIs) - If using SQL, provide the query for each pass separately - Output a merge log showing which records were combined and why </constraints>

<context> Data source: [CSV / API response / database export] Columns to normalize: [list each column and its current state — e.g. "phone: mixed formats (555-1234, (555) 123-4567, +1 5551234567)", "state: mix of abbreviations and full names"] Target format for each: [e.g. "phone: +1XXXXXXXXXX", "state: 2-letter abbreviation"] Tool: [Python / SQL / Excel / Google Sheets] </context> <task> Write a normalization pipeline that transforms each column to its target format: For each column: 1. Detection — identify all current format variations in the data 2. Transformation rules — map each variation to the target format 3. The complete code/formula 4. Edge cases that can't be auto-fixed (flag for manual review) 5. Validation — a check that confirms 100% of values now match the target format </task> <constraints> - Handle international formats where applicable (phone numbers, dates, addresses) - Don't silently drop data that doesn't match any known pattern — flag it - Preserve the original column and create a new normalized column alongside it - If using regex, comment each pattern explaining what it matches - Provide a before/after sample for each transformation - If any transformation is lossy (reduces information), warn explicitly </constraints>

<context> Data format: [emails / PDF extracts / web scrapes / log files / free-text survey responses] Sample data: [paste 3-5 representative examples] Target structure: [describe the structured output you want — e.g. "columns: sender, date, subject, action_items, deadline"] Volume: [number of records to process] Tool: [Python / Excel / Google Sheets / regex only] </context> <task> Create a parser that extracts structured data from this unstructured text: 1. Pattern analysis — identify the consistent and variable elements across my samples 2. Extraction rules — for each target field, the exact regex or parsing logic 3. Complete code that processes all records 4. Confidence score for each extraction (did the pattern match cleanly?) 5. Exception handling — what to do when the text doesn't match expected patterns 6. Output as [CSV / JSON / database INSERT statements] </task> <constraints> - The parser must handle variations in formatting, not just the exact samples provided - Build in a "fallback" column that captures the full original text for failed parses - Test the parser against the provided samples and show the output - If using regex, keep patterns readable — prefer multiple simple patterns over one complex one - Flag records where extraction confidence is below 80% - Include a summary: X records parsed successfully, Y flagged for review </constraints>

<context> Dataset: [describe the dataset — e.g. "customer records with 15 columns"] Critical columns: [list columns and expected data types/formats — e.g. "email: valid email format, age: integer 18-120, revenue: positive decimal, country: ISO 3166-1 alpha-2"] Business rules: [any cross-column rules — e.g. "if status = 'active', email must not be null", "end_date must be after start_date"] Tool: [Python / SQL / Excel / Google Sheets] </context> <task> Build a comprehensive data validation suite: For each column: 1. Type check — is the data the correct type? 2. Format check — does it match the expected pattern? 3. Range check — is it within acceptable bounds? 4. Completeness check — are required fields populated? 5. Cross-column check — do related columns pass business rules? Deliverables: - Complete validation code/formulas - A validation report: column, rule, records passing, records failing, failure rate - A "data quality score" (0-100) for the dataset - Specific rows to investigate (the worst offenders) </task> <constraints> - Don't just count NULLs — check for disguised missing data ("N/A", "none", "-", "0" used as placeholder) - Flag statistical outliers (values beyond 3 standard deviations) separately from rule violations - Validation must be re-runnable — design it as a repeatable check, not a one-time script - Output a clean/dirty split: validated records vs. records needing attention - Include a "fix suggestion" for each common failure pattern </constraints>

<context> Dataset: [describe your data — e.g. "monthly marketing spend (5 channels) and revenue over 3 years"] Dependent variable (Y): [what you're trying to predict — e.g. "monthly revenue"] Independent variables (X): [potential predictors — e.g. "Google Ads spend, Facebook spend, email campaigns sent, seasonality, price changes"] Tool: [Python / R / Excel / Google Sheets] Statistical background: [none / took a stats class / use regression regularly] </context> <task> Set up a regression analysis to answer: "[YOUR QUESTION — e.g. Which marketing channels have the strongest impact on revenue, and what's the expected ROI of increasing spend by 20%?]" Provide: 1. Data preparation steps — handling missing values, encoding categoricals, checking for multicollinearity (VIF scores) 2. The right type of regression for this problem (linear, multiple, logistic, polynomial) and why 3. Complete code to run the regression 4. How to interpret the output — R-squared, p-values, coefficients in plain English 5. Diagnostic checks — residual plots, normality test, heteroscedasticity 6. The business answer to my question, based on hypothetical but realistic output </task> <constraints> - Explain every statistical concept at my stated level — no unexplained jargon - If assumptions are violated (non-linearity, non-normal residuals), suggest the appropriate alternative - Include confidence intervals, not just point estimates - Warn about correlation vs. causation if the question implies causal claims - If the sample size is too small for reliable regression, say so and suggest what to do </constraints>

<context> Research question: [e.g. "Did our new pricing page increase conversion rates?"] Data: [describe your two groups — e.g. "Group A (old page): 1,200 visitors, 84 conversions. Group B (new page): 1,350 visitors, 118 conversions"] Sample sizes: [n per group] Significance level: [0.05 unless you have a reason for different] Tool: [Python / R / Excel / Google Sheets] </context> <task> 1. Identify the correct statistical test for this question (t-test, chi-square, Mann-Whitney, ANOVA, etc.) and explain why 2. State the null and alternative hypotheses in plain English 3. Check assumptions (normality, equal variance, independence, minimum sample size) 4. Run the test — provide complete code 5. Interpret the result: - p-value and what it means for my decision - Effect size (Cohen's d, odds ratio, etc.) and whether the difference is practically significant - Confidence interval for the difference 6. One-sentence recommendation: what should we do based on this result? </task> <constraints> - If assumptions are violated, run the appropriate non-parametric alternative and compare results - Don't just report "statistically significant" — always report effect size and practical significance - If the sample size is too small for reliable inference, calculate the minimum sample needed - Warn about multiple testing if I'm running several tests (Bonferroni correction) - Use two-tailed tests unless I explicitly state a directional hypothesis </constraints>

<context> Dataset: [describe variables — e.g. "20 columns of customer behavior metrics: visit frequency, pages viewed, time on site, support tickets, NPS score, churn (yes/no)"] Goal: [e.g. "find which behaviors predict churn"] Tool: [Python / R / Excel] Number of variables: [count] Number of records: [count] </context> <task> Perform a correlation and pattern discovery analysis: 1. Correlation matrix — all pairwise correlations with significance flags 2. Top 10 strongest correlations (excluding trivially obvious ones) 3. Surprising findings — correlations that are unexpectedly strong, weak, or reversed from intuition 4. Multivariate patterns — combinations of variables that together predict the target variable better than any single one 5. Visualization recommendations — which charts best reveal the patterns you found 6. Actionable insights — what these correlations suggest we should investigate or act on </task> <constraints> - Use Pearson for linear relationships, Spearman for non-linear — report both where they diverge - Flag spurious correlations that are likely driven by a confounding variable - Don't claim causation from correlation — suggest experiments to test causal hypotheses - If variables are on different scales, normalize before analysis - For high-dimensional data (>20 variables), suggest PCA or feature selection before exhaustive correlation - Include the code for a publication-quality correlation heatmap </constraints>