30 ChatGPT-5.5 Mini Prompts for Data Analysis — From CSV Cleaning to Dashboard-Ready Insights

30 Copy-Paste-Ready Prompts for Data Analysis with ChatGPT-5.5 Mini

Published: July 17, 2026  |  Author: Markos Symeonides

Introduction: Why ChatGPT-5.5 Mini is ideal for data analysis

ChatGPT-5.5 Mini stands out for day-to-day data analysis because it emphasizes practical speed, predictable costs, and strong reasoning guided by structured outputs. In typical analysis cycles—cleaning, exploration, transformation, statistics, and reporting—you benefit from low-latency iterations and compact, schema-driven answers that integrate neatly into notebooks, BI tools, and automated pipelines.

While model naming evolves, the “Mini” designation historically signals fast response times, efficient token usage, and support for core developer features such as JSON-structured responses, function calling/tool use, and safe code execution sandboxes. If your workspace includes file uploads, the model can summarize schemas, infer types, and suggest transformations rapidly. For teams building repeatable workflows, the consistency of “Mini” models makes it easier to embed them into dashboards, QA checks, or batch jobs without cost spikes. If you are new to structured prompting, see

For additional context on related AI capabilities and workflows, our comprehensive resource on The Big Prompt Engineering Story: What July 13’s News Means for Developers provides practical guidance and implementation strategies that complement the techniques discussed in this article.

for deeper context.

What you can expect in practice

• Speed: Rapid iterations when refining queries, adding constraints, or debugging data issues.
• Cost control: Mini-tier pricing historically enables frequent experimentation (e.g., many small EDA passes) without budget concerns.
• Accuracy through structure: JSON schemas, explicit assumptions, and requested validation steps help contain hallucinations and ensure reproducible outputs.
• Tooling: If Code Interpreter or function calling is available in your environment, the model can validate assumptions against your files and produce executable Python or SQL.

Capabilities snapshot for data teams

How to use these prompts effectively

These prompts are designed for copy-paste simplicity and structured outcomes. To get the most reliable results with ChatGPT-5.5 Mini:

• State your data context up front: file names, table names, column types, target variable, time granularity, business domain.
• Attach sample data: Upload a CSV/Parquet or paste a small excerpt (10–50 rows) and the schema. The model can inspect patterns, nulls, outliers, and categorical levels.
• Ask for specific output formats: JSON blocks with named fields for decisions, code snippets in Python/SQL/R, and short rationales.
• Iterate in small steps: Run a cleaning prompt, then an EDA prompt, then refine your hypothesis test. Each prompt below encourages validation or next actions.
• If Code Interpreter is available: Explicitly permit execution and request reproducible notebooks, unit checks, and saved artifacts. See

  For additional context on related AI capabilities and workflows, our comprehensive resource on How to Use ChatGPT Work to Build Websites and Presentations Without Code provides practical guidance and implementation strategies that complement the techniques discussed in this article.

  .

• Be explicit about assumptions: Sample size, independence, missingness mechanisms, experimental design—ask the model to state and verify them.
• Use deterministic modes when possible: Request a fixed seed for sampling and consistent output ordering for reproducibility.
• Keep privacy in mind: Replace PII with placeholders, and request differential summaries where appropriate.

Finally, chain prompts. For example, run the Missing Values (Prompt 1), then Summary Statistics (Prompt 6), then Hypothesis Testing (Prompt 16), and finally Executive Summary (Prompt 23). You can even ask the model to keep a running “analysis ledger” to cite decisions and provenance. For foundational cleaning strategies, you might also explore

Data-intensive workflows benefit significantly from AI automation capabilities. Our tutorial on OpenAI Codex Automation: How to Analyze Data Hands-Free with AI demonstrates how to set up hands-free data processing pipelines that handle analysis tasks autonomously.

and for exploratory techniques

For additional context on related AI capabilities and workflows, our comprehensive resource on How to Set Up ChatGPT Connectors for Automated Workflows: Integrating Slack, Google Drive, Jira, and 20+ Third-Party Apps with Scheduled Tasks provides practical guidance and implementation strategies that complement the techniques discussed in this article.

.

Prompts Section 1: Data Cleaning (1–5)

Prompt 1 — Handling Missing Values

Role: You are a data analyst using ChatGPT-5.5 Mini.
Goal: Diagnose and impute missing values with transparent logic and reproducible code.

Context:
- Dataset name: {dataset_name}
- File(s): {file_paths_or_uploads}
- Target columns of interest: {columns_of_interest}
- Domain notes (optional): {domain_notes}

Instructions:
1) Inspect missingness patterns (MCAR/MAR/MNAR guess), per-column null counts and percentages.
2) Propose imputation strategies by column type:
   - Numeric: mean/median, regression impute, KNN, or leave as NA with indicator.
   - Categorical: mode, new category "Unknown", or frequency-based impute.
   - Datetime: forward/back-fill within groups or carry-over rules.
3) State assumptions and risks (data leakage, bias, distorted variances).
4) Produce:
   - A JSON plan of imputations with fields:
     {"column": str, "dtype": str, "strategy": str, "params": dict, "risk": str}
   - Executable Python (pandas) to apply the plan; if Code Interpreter is available, ask for permission to run.
5) Validate: Report post-imputation nulls and summary stats deltas.

Output format:
- First, JSON with key "imputation_plan".
- Then, a Python code block that applies the plan and prints validation metrics.
- Keep it concise and deterministic (set seeds when needed).

If files are uploaded, load them; else, request a 20-row sample to infer dtypes.

Why it works: It frames missingness in statistical terms (MCAR/MAR/MNAR), asks for column-wise strategies, and requests a machine-executable plan plus validation, reducing ambiguity and leakage risk.

Expected output: A JSON list of imputation steps per column and a ready-to-run pandas script that imputes and prints before/after null counts and summary delta checks.

• Variations:
  • Add “group-wise” imputation by a key (e.g., customer_id, store_id).
  • Ask for scikit-learn Pipeline steps to persist imputers.
  • Switch output to R (dplyr/tidyr) or SQL (CASE/COALESCE).

Prompt 2 — Deduplication (Exact and Near-Duplicates)

Role: You are a data quality engineer.
Goal: Identify and resolve duplicates (exact and near-duplicates) with auditability.

Context:
- Dataset: {dataset_name}
- Primary keys (if any): {primary_keys}
- Candidate match fields: {match_fields}
- Tolerance for near-duplicates: {string_similarity_threshold} (e.g., 0.88)

Instructions:
1) Report exact duplicate counts by row, by key, and by selected field subsets.
2) For near-duplicates, propose similarity metrics (Levenshtein/Jaro-Winkler, token_set_ratio).
3) Output:
   - JSON "dedupe_plan" describing rules by level: exact, fuzzy, tie-breakers.
   - Python code to:
     a) flag duplicates and cluster near-duplicates,
     b) pick survivors using rules (most recent, most complete),
     c) write an audit table with group_id and chosen survivor.
4) State the risk of over-merging and how to review borderline cases.

Constraints:
- Do not drop rows without an audit trail.
- Provide a dry-run mode with counts only.

If tools available, ask permission to compute fuzzy matches; else, emit the code.

Why it works: It separates exact and fuzzy logic, encodes survivor rules, and emphasizes audit trails and dry-runs—core to safe deduplication.

Expected output: A structured plan and Python code that flags duplicates, clusters near-duplicates, and creates an audit table with survivor selection rationale.

• Variations:
  • Emit SQL for warehouse-native dedupe using window functions.
  • Use domain tie-breakers (e.g., verified_email, latest_update_ts).
  • Generate a review CSV for human verification.

Prompt 3 — Type Conversion and Coercion

Role: You are a data wrangler.
Goal: Enforce correct dtypes and coerce problematic values with an auditable summary.

Context:
- Dataset: {dataset_name}
- Known target dtypes (col: dtype): {desired_dtypes}
- Timezone/datetime expectations: {tz_and_formats}

Instructions:
1) Infer current dtypes; compare to desired; list conflicts and repr samples.
2) Plan conversions:
   - numerics (strip symbols, thousands separators),
   - categoricals (normalize labels, consistent casing),
   - datetimes (parse multi-format, set timezone).
3) Output:
   - JSON "coercion_plan" with {"column","current","target","rules","examples"}.
   - Python code to apply conversions with error='coerce' and a "coercion_report" table.
4) Validate: Show counts of coercion, example rows, and irreversible-loss notes.

Formatting:
- Print a compact before/after schema.
- Return deterministic samples (seeded).

Why it works: By explicitly comparing intended and current dtypes, it creates a concrete conversion plan and a report of any lossy transformations.

Expected output: A side-by-side schema diff, JSON rules per column, and code that coerces values while capturing a detailed coercion report.

• Variations:
  • Emit equivalent dbt model SQL for warehouse transformations.
  • Include locale-aware number/date parsing.
  • Add unit normalization (e.g., kg vs. lbs) with conversion factors.

Prompt 4 — Outlier Detection and Treatment

Role: You are a statistician safeguarding model robustness.
Goal: Detect outliers and propose treatments without discarding valuable signal.

Context:
- Numeric columns to scan: {numeric_cols}
- Grouping keys for context-aware thresholds (optional): {group_keys}
- Treatment policy: {cap_winsorize_remove_flag}

Instructions:
1) Compute per-column and per-group (if provided) outlier flags using:
   - IQR (1.5x, adjustable), z-score (|z|>3), and robust z-score (MAD).
2) Summarize outlier rates and their potential business meaning.
3) Output:
   - JSON "outlier_policy" with thresholds and actions per column.
   - Python code to implement chosen policy (flag/cap/remove), preserving raw values.
4) Validate: Before/after distribution snapshots and a bias note (e.g., seasonal spikes).

Constraints:
- Ensure reproducibility; avoid leakage into test folds.
- Keep an audit trail column: is_outlier, outlier_method.

Ask to execute if tools are enabled; else, provide code only.

Why it works: It compares complementary methods (IQR, z, robust z), documents thresholds, and preserves raw values via flags for traceability.

Expected output: A treatment policy and code that adds outlier flags/caps, prints distribution comparisons, and highlights any segment-specific bias.

• Variations:
  • Use seasonal decomposition residuals for time-series outliers.
  • Request plots (boxplots/histograms) if visualization tools are available.
  • Emit SQL using PERCENTILE_CONT for capping in-warehouse.

Prompt 5 — Standardization and Scaling

Role: You are preparing data for modeling.
Goal: Standardize and scale features with a reproducible, persistable pipeline.

Context:
- Features to scale: {feature_list}
- Scaling type: {standard|minmax|robust|unit_length}
- Train/validation split policy: {split_policy}
- Persistence: {persist_scaler_artifacts_yes_no}

Instructions:
1) Propose scaling by feature group and justify (e.g., heavy tails → RobustScaler).
2) Output:
   - JSON "scaling_plan" per feature with scaler and parameters.
   - scikit-learn Pipeline code that:
     a) fits on train only,
     b) serializes artifacts (joblib),
     c) transforms train/val/test consistently.
3) Validate: Print means/variances (or ranges) post-transform and leakage checks.

Constraints:
- Fixed random_state for reproducibility.
- Include inverse_transform examples for interpretation.

Ask before executing code if tools are enabled.

Why it works: It separates planning from execution, prevents leakage via proper splits, and ensures artifacts are saved for downstream inference.

Expected output: A JSON scaling plan with per-feature rationale and a sklearn pipeline that fits, saves, and validates transformations with reproducible seeds.

• Variations:
  • Add quantile transformation for highly skewed data.
  • Emit equivalent Spark ML pipeline code for large datasets.
  • Include per-group standardization (fit per entity).

Prompts Section 2: Exploratory Data Analysis (6–10)

Prompt 6 — Summary Statistics by Segment

Role: You are an EDA specialist.
Goal: Produce concise summary statistics overall and by key segments.

Context:
- Dataset: {dataset_name}
- Segment variables (e.g., region, plan): {segment_vars}
- Numeric targets: {numeric_targets}
- Categorical targets: {categorical_targets}

Instructions:
1) Overall: count, missing%, mean/median/std, min/max for numeric; top-k frequencies for categoricals.
2) By segment: same metrics per segment value (limit k=10).
3) Output:
   - JSON "eda_summary" with two blocks: overall, by_segment.
   - Python code to compute these summaries and print neat tables.
4) Diagnostics: Flag data issues (zero-inflation, extreme skewness, high cardinality).

Constraints:
- Deterministic: sorted outputs, fixed top-k.
- Include notes on sample size per segment.

If files are uploaded, run; else, ask for sample data or schema.

Why it works: It balances breadth (overall) and depth (by-segment), and encodes the output into JSON plus tables for immediate reuse.

Expected output: Segment-aware summary JSON and Python code to replicate the summaries, with diagnostic notes about skewness or sparse categories.

• Variations:
  • Emit SQL GROUP BYs for warehouse-native EDA.
  • Include trimmed means/medians for robustness.
  • Add stratification by time windows (e.g., monthly cohorts).

Prompt 7 — Distribution Analysis and Normality Checks

Role: You are analyzing distributions for modeling assumptions.
Goal: Describe shapes, tails, and normality; propose transformations if needed.

Context:
- Columns to analyze: {columns}
- Binning preference: {bin_strategy} (e.g., Freedman–Diaconis)
- Need normality tests? {yes_no}

Instructions:
1) Compute skewness and kurtosis per column; describe shape and implications.
2) If normality tests requested, run Shapiro–Wilk (n<=5000) or Anderson–Darling.
3) Recommend transformations (log1p, Box–Cox, Yeo–Johnson) with caveats (zeros/negatives).
4) Output:
   - JSON "distribution_report" with metrics, p-values, and recommended transforms.
   - Python code to apply transforms and plot histograms/QQ if tools allowed.

Constraints:
- Clear multiple-testing caveats; adjust alpha if many columns.
- Deterministic plotting seeds.

Ask before running code if execution is available.

Why it works: It explicitly requests distribution shape metrics and objective tests, then recommends viable transformations with the right caveats.

Expected output: JSON containing skew/kurtosis and normality p-values, plus code to apply suggested transformations and (optionally) generate diagnostic plots.

• Variations:
  • Focus on tail behavior for VaR/quantile models.
  • Produce density estimates and compare bandwidths.
  • Request non-parametric summaries when normality fails.

Prompt 8 — Correlation Discovery (Mixed Data Types)

Role: You are exploring relationships among mixed-type variables.
Goal: Compute correlations for numeric-numeric, numeric-categorical, and categorical-categorical.

Context:
- Numeric columns: {num_cols}
- Categorical columns: {cat_cols}
- Correlation thresholds of interest: {thresholds}

Instructions:
1) Numeric-numeric: Pearson and Spearman; flag discrepancies.
2) Numeric-categorical: point-biserial (binary), ANOVA-based eta-squared otherwise.
3) Categorical-categorical: Cramér's V with bias correction.
4) Output:
   - JSON "correlation_matrix" with method-specific blocks and top pairs above thresholds.
   - Python code to compute metrics and a heatmap spec (no plot unless allowed).
5) Warn about spurious correlations, sample size, and multiple comparisons.

Constraints:
- Deterministic ordering by absolute effect size.
- Include n per pair and missingness handling.

Execute if tools allowed; otherwise, emit code only.

Why it works: It picks appropriate measures for mixed types and asks for both the numbers and a visualization spec while highlighting statistical caveats.

Expected output: A JSON structure of correlations by method, ranked high-impact pairs, and code to compute them plus a heatmap configuration.

• Variations:
  • Add partial correlations controlling for confounders.
  • Emit SQL for correlation in-warehouse (approximate for large data).
  • Include nonlinear tests (MICe) for complex relationships.

Prompt 9 — Pattern Identification (Seasonality, Cohorts, Text)

Role: You are scanning for latent patterns.
Goal: Surface seasonality, cohort effects, and text themes that may drive outcomes.

Context:
- Time column and grain: {time_col} @ {grain}
- Cohort definition (e.g., first_purchase_month): {cohort_def}
- Text column(s) (optional): {text_cols}
- Outcome of interest: {outcome}

Instructions:
1) Seasonality: detect weekly/monthly/annual components via STL or autocorrelation summaries.
2) Cohorts: build retention or performance matrices by cohort vs. period.
3) Text: extract frequent keywords/topics (lightweight), link to outcome if feasible.
4) Output:
   - JSON "pattern_report" with seasonality stats, cohort tables, and text themes.
   - Python code to compute ACF/PACF summaries, cohort pivot, and simple keyword TF-IDF.

Constraints:
- Avoid heavy models unless allowed; keep portable.
- Note sample-size limits for cohort stability.

Ask before running tools; else provide code.

Why it works: It unifies time, cohort, and text cues in one sweep with actionable outputs and hints for where to dig deeper.

Expected output: A JSON report with seasonality indicators, a cohort pivot, and key terms; plus minimal Python to reproduce results.

• Variations:
  • Replace TF-IDF with keyphrase extraction (YAKE/Rake) if text is short.
  • Add domain-specific stopwords and stemming/lemmatization.
  • Compute period-over-period changes per cohort.

Prompt 10 — Segmentation Heuristics (Pre-Clustering EDA)

Role: You are preparing for clustering.
Goal: Recommend candidate feature sets and cluster counts with justifications.

Context:
- Candidate features: {feature_list}
- Scaling status: {scaled_or_not}
- Suspected segments: {business_hypotheses}

Instructions:
1) Assess feature suitability (scales, sparsity, correlation redundancy).
2) Propose k values using heuristics (elbow, silhouette, gap statistic).
3) Output:
   - JSON "segmentation_plan" with chosen features, k candidates, and validation metrics to compute.
   - Python code to standardize (if needed), run KMeans for k in range, and compute silhouette.
4) Notes on interpretability vs. performance and alternative algorithms (GMM, HDBSCAN).

Constraints:
- Deterministic seeds.
- Do not overfit to tiny samples; warn if n is small.

Execute if tools allowed; else, emit code.

Why it works: It narrows features, proposes k values with standard diagnostics, and maintains a focus on interpretability before committing to an algorithm.

Expected output: A segmentation plan in JSON and Python code to try k ranges with silhouette scores to guide selection.

• Variations:
  • Use PCA/UMAP for dimensionality hints.
  • Profile segments with medians and category proportions.
  • Emit SQL for feature assembly in a warehouse.

Prompts Section 3: Data Transformation (11–15)

Prompt 11 — Pivot Tables (Wide and Long Views)

Role: You are shaping data for analysis.
Goal: Create pivot tables (wide) and tidy (long) reshapes for flexible EDA.

Context:
- Index keys: {index_keys}
- Column keys: {column_keys}
- Values and aggregations: {values_and_aggs} (e.g., revenue=sum, orders=count)
- Fill policy for missing combinations: {fill_policy}

Instructions:
1) Output JSON "pivot_specs" detailing index, columns, values, aggs, and fill policy.
2) Provide Python code:
   - Build pivot_table,
   - Fill missing combinations,
   - Create a tidy version via melt with explicit var/value names.
3) Validate: Print sizes and example slices for both shapes.

Constraints:
- Deterministic sorting.
- Safe handling of multi-index.

Execute if tools available; else, provide code only.

Why it works: It couples explicit pivot specs with code and tidy reshaping, so downstream analyses (plots, models) can consume either format reliably.

Expected output: A pivot specification JSON and pandas code to produce both wide and long formats with validation prints.

• Variations:
  • Emit SQL PIVOT/UNPIVOT equivalents for your warehouse.
  • Add custom subtotal/grand total rows.
  • Ensure consistent category ordering via CategoricalDtype.

Prompt 12 — Window Functions and Rolling Aggregations

Role: You are crafting time-aware features.
Goal: Compute rolling, expanding, and windowed statistics.

Context:
- Entity key(s): {entity_keys}
- Time column and frequency: {time_col} @ {freq}
- Metrics: {metrics} (e.g., sales, sessions)
- Windows: {windows} (e.g., 7D, 28D)

Instructions:
1) Output JSON "window_plan" with window sizes, alignment, and min_periods.
2) Provide Python code to:
   - Sort and group by entity/time,
   - Compute rolling means/sums/std, expanding stats,
   - Add lag/lead features.
3) Validate: Show edge handling at series starts and missing periods interpolation (if any).

Constraints:
- Use deterministic fill rules.
- Warn about leakage if windows include future data.

Ask to execute if tools exist; else, emit code.

Why it works: It encodes window math, grouping, and leakage safeguards in a single prompt to reduce common time-series pitfalls.

Expected output: A JSON window plan and code to compute rolling/lag features, with checks for boundaries and missing periods.

• Variations:
  • Emit SQL window functions (OVER PARTITION BY ORDER BY ROWS/RANGE).
  • Add exponentially weighted averages (EWM).
  • Align with business calendars (iso-week, fiscal periods).

Prompt 13 — Feature Engineering Blueprint

Role: You are designing features for predictive modeling.
Goal: Propose engineered features with leakage controls and cost/benefit notes.

Context:
- Target variable: {target}
- Prediction timepoint definition: {prediction_timepoint}
- Available raw columns: {raw_columns}
- Constraints (compute, explainability): {constraints}

Instructions:
1) Recommend feature families: interactions, ratios, counts, recency/frequency, encodings.
2) For each, provide:
   - JSON "feature_blueprint": {"name","definition","leakage_risk","cost","importance_guess"}.
   - Python code snippets to compute them safely relative to prediction time.
3) Validate: Flag any features that require future data or label leakage.

Constraints:
- Deterministic seeds for stochastic encoders.
- Keep code modular and testable.

Ask to run if tools allowed; else output code only.

Why it works: It defines features around prediction-time rules, explicitly flags leakage, and weighs compute cost and expected impact.

Expected output: A JSON blueprint of candidate features and code snippets to generate them without leaking future information.

• Variations:
  • Generate domain-specific features (e.g., RFM for commerce).
  • Emit Spark code for large-scale feature generation.
  • Include SHAP-ready notes for interpretability pipelines.

Prompt 14 — Normalization and Encoding Pipeline

Role: You are creating a preprocessing pipeline.
Goal: Normalize numerical features and encode categoricals with reproducible artifacts.

Context:
- Numeric columns: {numeric_cols}
- Categorical columns: {categorical_cols}
- Encoding strategy: {one_hot|ordinal|target|hashing}
- Rare category handling threshold: {min_count}

Instructions:
1) Output JSON "preprocess_plan" detailing normalization and encoding per column.
2) Provide scikit-learn ColumnTransformer + Pipeline code:
   - Normalization (StandardScaler/MinMaxScaler/RobustScaler),
   - Encoding (OneHotEncoder with handle_unknown, OrdinalEncoder, TargetEncoder*),
   - Rare category bucketing to "__rare__".
3) Persist fitted transformers and output feature names mapping.

Constraints:
- Deterministic (random_state for target/hashing encoders).
- Note: Use a well-known TargetEncoder implementation if available; else, propose an alternative.

If tools allowed, ask to install needed packages; else, emit code.

Why it works: It composes numeric normalization with category encoding in a single, persistable pipeline and anticipates rare-category pitfalls.

Expected output: A JSON preprocessing plan and scikit-learn code that fits on train data, transforms val/test consistently, and saves artifacts and feature name maps.

• Variations:
  • Swap in binary encoding or leave-one-out target encoding.
  • Emit statsmodels/R code for alternative stacks.
  • Warehouse-native encoding using lookup tables.

Prompt 15 — Time-Series Decomposition and Calendar Features

Role: You are prepping time-series for forecasting.
Goal: Decompose series and add calendar/holiday features.

Context:
- Time series column/value: {time_col}/{value_col}
- Frequency (D/W/M): {freq}
- Country/region holidays: {holiday_region}
- Known events (product launches, promos): {events}

Instructions:
1) Perform STL decomposition (trend/seasonal/resid); summarize seasonal strength.
2) Generate calendar features: dow, dom, week, month, quarter, holiday flags, event windows.
3) Output:
   - JSON "ts_features" with decomposition metrics and feature list.
   - Python code for decomposition and feature creation.
4) Validate: Print seasonal strength metrics and a quick residual ACF summary.

Constraints:
- Deterministic frequency and index handling.
- Warn if series too short for STL.

Execute if tools allowed; else, emit code.

Why it works: It pairs STL insights with calendar features, yielding interpretable components for baseline models or model diagnostics.

Expected output: A JSON of decomposition stats and calendar features, plus Python code to compute them and quick residual diagnostics.

• Variations:
  • Add Fourier terms for complex seasonality.
  • Use Prophet-compatible regressors.
  • Include moving holiday handling (Easter, Lunar New Year).

Prompts Section 4: Statistical Analysis (16–20)

Prompt 16 — Hypothesis Testing (Test Selection and Execution)

Role: You are a statistician validating an effect.
Goal: Choose and run the correct hypothesis test with assumptions and effect sizes.

Context:
- Hypothesis: {null_and_alt}
- Data structure (paired/unpaired, normality, variances): {structure_notes}
- Variables and groups: {variables_and_groups}
- Alpha and power targets: {alpha_power}

Instructions:
1) Select appropriate test (t-test variants, Mann–Whitney, chi-square, Fisher, ANOVA/ANCOVA) with rationale.
2) State assumptions and how to check them; propose nonparametric backup if violated.
3) Output:
   - JSON "hypothesis_plan" with test, assumptions, effect size (Cohen's d, r, η²).
   - Python code to run the test, compute effect size and confidence intervals.
4) Validate: Provide interpretation language and caveats.

Constraints:
- Multiple testing correction if many hypotheses.
- Deterministic seeds for resampling CIs.

Execute if tools allowed; else, emit code.

Why it works: It enforces test selection transparency, computes effect sizes, and frames results in plain language with assumptions and fallbacks.

Expected output: A structured test plan, executable code for the test and effect size, and a clear interpretation at the chosen alpha/power levels.

• Variations:
  • Include covariate adjustment (ANCOVA) when appropriate.
  • Add permutation tests for robustness.
  • Emit R (stats, car) code as an alternative.

Prompt 17 — Regression Analysis with Diagnostics

Role: You are modeling a numeric outcome.
Goal: Fit regression with diagnostics and mitigation steps.

Context:
- Outcome: {y}
- Predictors: {X}
- Concerns: {heteroskedasticity|multicollinearity|nonlinearity}
- Train/val split or CV: {split_or_cv}

Instructions:
1) Fit OLS; provide coefficients, CIs, p-values, R²/adj-R².
2) Diagnostics: residual plots spec, heteroskedasticity tests (Breusch–Pagan), VIF for multicollinearity.
3) If issues detected, propose remedies (robust SEs, transformations, regularization, interactions).
4) Output:
   - JSON "regression_report" with coefficients and diagnostics.
   - Python code (statsmodels/sklearn) to fit, test, and plot (if allowed).

Constraints:
- Deterministic splits where needed.
- Avoid leakage from target encodings unless cross-fitted.

Ask to execute if tools available; else, emit code only.

Why it works: It treats regression as a modeling plus diagnostics problem, surfacing issues and remedies, not just coefficients.

Expected output: A regression report JSON with coefficients and test results, plus code to fit the model and produce diagnostic checks.

• Variations:
  • Switch to GLMs (Poisson, logistic) based on outcome type.
  • Add regularization (Lasso/Ridge/ElasticNet) and cross-validation.
  • Provide marginal effects for interpretability.

Prompt 18 — A/B Test Evaluation (Frequentist and Bayesian)

Role: You are evaluating an experiment.
Goal: Compute lift, uncertainty, and decision recommendations for A/B or multivariate tests.

Context:
- Metric type (binary, count, continuous): {metric_type}
- Groups and sizes: {groups_and_ns}
- Conversions/means/variances: {metrics}
- Design notes (randomization, exposure): {design_notes}

Instructions:
1) Frequentist: difference in means/proportions, pooled/unpooled variances as appropriate; CIs.
2) Bayesian (optional): Beta-Binomial (binary) or Normal-Normal/Student-T for continuous; posterior of lift and P(B>A).
3) Output:
   - JSON "ab_results" with group stats, lift, uncertainty, and decision rule outcome (at alpha or posterior threshold).
   - Python code to compute both approaches and a simple power/futility check.
4) Diagnostics: Check sample ratio mismatch (SRM) and variance inflation.

Constraints:
- Deterministic seeds for simulations.
- Clear guidance on minimal detectable effect and power.

Ask to execute if tools available; else, emit code only.

Why it works: It covers both frequentist and Bayesian lenses, includes SRM/power checks, and reports a decision rule—what most experiment owners need.

Expected output: JSON with group-wise stats, lift and uncertainty, plus code for both frequentist and optional Bayesian analyses and power checks.

• Variations:
  • Handle sequential tests with alpha spending notes.
  • Support CUPED or covariate adjustment.
  • Extend to multi-arm bandit summaries.

Prompt 19 — Confidence Intervals via Bootstrap

Role: You are quantifying uncertainty.
Goal: Compute bootstrap confidence intervals for key statistics.

Context:
- Statistic(s): {statistic} (e.g., mean, median, quantile, ratio)
- Resamples: {B} (e.g., 2000)
- CI method: {percentile|BCa|basic}
- Grouping (optional): {group_keys}

Instructions:
1) Define the statistic function (handle NaNs).
2) Bootstrap B resamples; compute CI using chosen method.
3) Output:
   - JSON "bootstrap_results" with point estimate, CI bounds, and coverage notes.
   - Python code to run the bootstrap with deterministic seeds.
4) Diagnostics: Warn about heavy tails or dependence that affect bootstrap validity.

Constraints:
- Reproducible seeds.
- Efficient implementation; vectorize where possible.

Ask to execute if tools are enabled; else, emit code.

Why it works: It enforces a clear statistic definition, deterministic computation, and appropriate CI methodology with caveats.

Expected output: A bootstrap summary JSON and Python code that computes resamples, intervals, and diagnostics on assumptions.

• Variations:
  • Block bootstrap for time-series.
  • Bootstrap ratio metrics with bias notes.
  • Parallelize using joblib for large B.

Prompt 20 — Trend Analysis and Non-Parametric Tests

Role: You are validating trends over time.
Goal: Quantify monotonic trends robustly, with or without seasonality.

Context:
- Series: {series_name}
- Time granularity: {granularity}
- Seasonal strength known? {yes_no}
- Outlier handling: {policy}

Instructions:
1) If seasonality strong, seasonally adjust (STL) before trend test.
2) Apply Mann–Kendall test for monotonic trend; estimate Theil–Sen slope.
3) Output:
   - JSON "trend_report" with p-value, slope, and seasonal-adjustment notes.
   - Python code to compute STL (optional), Mann–Kendall, and Theil–Sen.
4) Diagnostics: State sensitivity to outliers and missing periods.

Constraints:
- Deterministic decomposition and seeds.
- Warn about short series and low power.

Ask to run if tools allowed; else provide code only.

Why it works: It separates seasonal adjustment from trend inference and uses non-parametric methods robust to non-normal errors.

Expected output: A JSON trend report and code to compute STL (if needed), Mann–Kendall test statistics, and Theil–Sen slope estimates.

• Variations:
  • Segment the trend pre/post a known breakpoint (Chow test alternative with caution).
  • Use rolling trends to see local changes.
  • Add visualization spec for slope overlays.

Prompts Section 5: Visualization & Reporting (21–25)

Prompt 21 — Chart Recommendations and Specs

Role: You are a data visualization advisor.
Goal: Recommend the right chart type(s) with encoding specs and accessibility notes.

Context:
- Analytical question: {question}
- Variables and types: {vars_and_types}
- Constraints (small multiples, color limits, print/export): {viz_constraints}
- Tooling: {matplotlib|seaborn|plotly|vega-lite|BI_tool}

Instructions:
1) Recommend chart types with rationale (e.g., distribution vs. comparison vs. relationship).
2) Provide a JSON "chart_specs" including:
   {"type","x","y","color","facet","size","ordering","annotations","accessibility"}
3) Output ready-to-run code for the chosen tool(s), with deterministic styling.
4) Include colorblind-safe palettes and annotation guidelines.

Constraints:
- Avoid 3D unless necessary.
- Keep labels and scales explicit.

If plots possible, ask permission to render; else provide code/spec only.

Why it works: It translates an analytical question into explicit encodings, chart choices, and accessible, reproducible code.

Expected output: A JSON chart specification and plotting code for the selected library or BI platform with consistent styles and annotations.

• Variations:
  • Generate alternative specs optimized for mobile.
  • Produce Vega-Lite JSON for dashboard embedding.
  • Offer small-multiples for high-cardinality categories.

Prompt 22 — Dashboard Layout Blueprint

Role: You are a BI architect.
Goal: Propose a dashboard layout that aligns KPIs, diagnostics, and narratives.

Context:
- Audience: {executive|product|ops}
- KPIs: {kpis}
- Data refresh cadence: {refresh_cadence}
- Interactivity needs: {filters, drilldowns}

Instructions:
1) Output JSON "dashboard_blueprint" with sections:
   [{"title","purpose","charts","interactions","owner","refresh"}]
2) Provide layout guidance (grid, responsive), visual hierarchy, and alert thresholds.
3) Provide code/spec (Vega-Lite/Plotly Dash/Streamlit) to scaffold the layout.

Constraints:
- Accessibility: font sizes, contrast, keyboard navigation.
- Deterministic theming.

Ask to scaffold app if tools allowed; else, provide code/spec only.

Why it works: It formalizes dashboard intent, structure, ownership, and refresh in a portable JSON so engineering can implement consistently.

Expected output: A dashboard blueprint JSON and a skeleton app or spec that can be extended with data bindings and authentication.

• Variations:
  • Add role-based views and metric definitions (source of truth).
  • Emit dbt exposures or lineage notes for governance.
  • Provide print/PDF-friendly layouts for exec packs.

Prompt 23 — Executive Summary Generator

Role: You are an analytics translator.
Goal: Create a concise, defensible executive summary from analysis results.

Context:
- Business objective: {objective}
- Key findings (paste or reference prior JSONs): {findings_refs}
- Risks/assumptions: {risks_assumptions}
- Next actions: {next_actions}

Instructions:
1) Produce a 250–350 word narrative with:
   - Objective and context,
   - 3–5 key insights with magnitudes and CIs if relevant,
   - Risks, assumptions, and data quality notes,
   - 2–3 prioritized recommendations.
2) Output JSON "exec_summary" with fields:
   {"headline","supporting_points":[...],"risks":[...],"actions":[...]}
3) Provide a formatted Markdown block for direct sharing.

Constraints:
- No hype; use measured language.
- Cite metrics precisely and tie to decisions.

If prior prompt outputs exist, integrate them concisely.

Why it works: It compels clarity and brevity, mapping insights to actions and constraints, and outputs in both JSON and human-readable formats.

Expected output: A JSON summary plus a polished Markdown narrative suitable for emails or docs.

• Variations:
  • Generate role-specific variants (exec vs. product vs. ops).
  • Include a one-slide storyboard outline.
  • Add a risks register table for program managers.

Prompt 24 — Automated Report Template (Markdown/HTML)

Role: You are automating recurring analytics reports.
Goal: Create a parameterized report template with sections and data placeholders.

Context:
- Report cadence: {weekly|monthly|quarterly}
- Audience and scope: {audience_scope}
- Data sources: {sources}
- KPIs and targets: {kpis_targets}

Instructions:
1) Output JSON "report_template" with:
   {"title","sections":[{"name","purpose","inputs","figures","tables"}],"schedule","owner"}
2) Provide a Markdown and HTML template with Jinja-style placeholders {{like_this}} for data binding.
3) Include versioning header and changelog area.
4) Provide a minimal Python script to render template + attach charts.

Constraints:
- Deterministic ordering of sections.
- Accessibility in HTML (alt text, semantics).

Ask to write files if tools allowed; else, print code.

Why it works: It yields both a structured spec and ready templates that a scheduler or CI pipeline can populate and publish.

Expected output: A JSON template spec, Markdown/HTML with placeholders, and a Python script that fills and exports the report.

• Variations:
  • Switch to Quarto or RMarkdown.
  • Integrate with Slack/Email notifications.
  • Add parameter sets for regions/products.

Prompt 25 — Storytelling with Data (Narrative Arc and Visual Sequence)

Role: You are crafting a persuasive data story.
Goal: Align narrative arc with visuals and evidence.

Context:
- Audience: {audience}
- Core message: {core_message}
- Evidence inventory (charts/tables): {evidence_list}
- Constraints (time limit, medium): {constraints}

Instructions:
1) Define a narrative arc: setup → conflict → insight → resolution → next steps.
2) Map evidence to each arc step; specify chart sequence and annotations.
3) Output:
   - JSON "storyboard" with steps, visuals, and key talking points,
   - A script outline (bullet points with timing).
4) Accessibility: Ensure color/label clarity and alternative text.

Constraints:
- Avoid chart overload; prefer 5–7 visuals.
- Deterministic ordering and consistent styling.

Provide as JSON + Markdown ready to present.

Why it works: It converts disparate findings into a structured narrative, aligning visuals and talking points to the audience’s decision needs.

Expected output: A storyboard JSON and a presentation script outline with recommended charts and annotations.

• Variations:
  • Generate a slide-by-slide deck outline with figure captions.
  • Offer a 3-minute “elevator pitch” variant.
  • Provide a technical appendix index for details.

Prompts Section 6: Advanced Analytics (26–30)

Prompt 26 — Predictive Modeling Setup (Baselines to Metrics)

Role: You are a machine learning engineer.
Goal: Frame the problem, define baselines, splits, and metrics before modeling.

Context:
- Prediction goal: {classification|regression|ranking}
- Target: {target}
- Features: {feature_list}
- Constraints (latency, fairness, cost): {constraints}

Instructions:
1) Problem framing: define objective, loss function, and business metric tie-in.
2) Baselines: naive predictors, dummy models, simple linear/logistic.
3) Splits: train/val/test with temporal or group awareness and leakage checks.
4) Metrics: select and justify (AUC/PR-AUC/F1/MAE/RMSE/NDCG).
5) Output:
   - JSON "modeling_plan" with baselines, splits, metrics, and risk notes.
   - Python code scaffolding (sklearn) to implement baselines and evaluation.

Constraints:
- Deterministic seeds and split reproducibility.
- Track data versions and feature schema hashes.

Ask to execute if tools allowed; else, provide code.

Why it works: It forces clarity on goals, baselines, data splits, and metrics prior to model complexity, which prevents wasted cycles.

Expected output: A modeling plan JSON and baseline code with splits, metrics, and reproducible configuration.

• Variations:
  • Include cost-sensitive learning or class weights.
  • Add fairness metrics and demographic parity checks.
  • Emit MLflow tracking hooks.

Prompt 27 — Clustering and Cluster Profiling

Role: You are discovering natural groupings.
Goal: Fit clustering and produce interpretable cluster profiles.

Context:
- Prepared features: {features_preprocessed}
- Desired k or algorithm: {k_or_algo}
- Interpretability needs: {profile_depth}

Instructions:
1) Recommend algorithm(s) (KMeans, GMM, HDBSCAN) based on data traits.
2) Fit clustering (range of k if needed); compute validation metrics (silhouette, Davies–Bouldin).
3) Output:
   - JSON "cluster_model" (algo, params, metrics),
   - Cluster profiling tables (medians, category shares) as JSON,
   - Python code to fit and profile clusters.
4) Label clusters with human-readable names based on profiles.

Constraints:
- Deterministic seeds for reproducibility.
- Warn about feature scaling and outlier sensitivity.

Ask to execute if tools allowed; else, emit code.

Why it works: It marries algorithmic selection with human-readable profiling and clear validation metrics, boosting stakeholder trust.

Expected output: A JSON describing the chosen clustering and profiles, plus code to train, score, and summarize clusters.

• Variations:
  • Use soft clustering (GMM) and report membership probabilities.
  • Add post-cluster decision rules or targeting criteria.
  • Emit a UMAP scatter spec for qualitative inspection.

Prompt 28 — Anomaly Detection and Alerting

Role: You are building detection for rare events.
Goal: Detect anomalies with explainable thresholds and alert schemas.

Context:
- Data type: {point_series|multivariate|transactions}
- Sensitivity target (TPR/FPR trade-off): {sensitivity}
- Known anomaly examples (if any): {examples}

Instructions:
1) Propose methods (Isolation Forest, LOF, robust z-score), justify choice.
2) Fit/score; determine thresholds using validation or quantiles.
3) Output:
   - JSON "anomaly_model" (method, params, threshold rationale),
   - Alert schema JSON {"id","timestamp","score","is_anomaly","explanation"},
   - Python code to train, score, and emit alerts.
4) Provide an evaluation plan using precision@k and alert review sampling.

Constraints:
- Deterministic seeds for reproducibility.
- Avoid training on known anomalies (if labeled).

Ask to execute if tools available; else, provide code.

Why it works: It ties modeling to a concrete alert schema and evaluation plan, making operationalization straightforward.

Expected output: A JSON model spec with threshold logic, an alert JSON schema, and code to train, score, and emit interpretable alerts.

• Variations:
  • Add seasonal baselines for time-of-day/day-of-week anomalies.
  • Use reconstruction error from autoencoders (if deep tools allowed).
  • Include suppression for duplicate events within cool-down windows.

Prompt 29 — Forecasting with Cross-Validation

Role: You are forecasting time-series.
Goal: Build and evaluate forecasts with rolling-origin cross-validation.

Context:
- Series: {series_name}
- Frequency: {freq}
- Horizon: {h}
- Exogenous regressors (optional): {exog}

Instructions:
1) Choose candidate models (ARIMA/SARIMA, ETS, Prophet-like); justify based on seasonality and trend.
2) Implement rolling-origin (time-series CV) with multiple folds.
3) Output:
   - JSON "forecast_plan" (models, params grid, CV folds, metrics like MAPE/MASE),
   - Python code to fit/evaluate models and select the best per fold,
   - Forecast generation code with CIs.
4) Diagnostics: Residual checks and stability across folds.

Constraints:
- Deterministic seeds and index alignment.
- Warn about sparse exogenous signals.

Ask to execute if tools allowed; else, emit code only.

Why it works: It emphasizes proper time-series CV, model comparison, and uncertainty, which are critical for trustworthy forecasts.

Expected output: A forecast plan JSON, evaluation code across folds, and code to generate forecasts with confidence intervals for the chosen model.

• Variations:
  • Add hierarchical reconciliation for multi-level series.
  • Use Prophet-compatible seasonalities and regressors.
  • Emit in-warehouse forecasts using SQL UDFs (where supported).

Prompt 30 — Recommendation System Primer (Implicit Feedback)

Role: You are prototyping recommendations.
Goal: Set up an implicit-feedback recommender with evaluation.

Context:
- Events: {user_id, item_id, event_ts, signal (views/clicks/purchases)}
- Sparsity level and scale: {sparsity_scale}
- Cold-start constraints: {cold_start_policy}

Instructions:
1) Convert events to implicit signals (confidence weights).
2) Train an implicit MF model (ALS) or nearest-neighbor baseline; justify choice.
3) Output:
   - JSON "recsys_plan" (model, params, weighting, cold-start),
   - Python code to train, generate top-N per user, and compute MAP@K/NDCG@K.
4) Provide fallback logic for cold-start users/items.

Constraints:
- Deterministic seeds and reproducible splits (temporal when appropriate).
- Avoid leakage from future interactions in evaluation.

Ask to execute if tools allowed; else, emit code.

Why it works: It captures the essential steps of an implicit-feedback recommender, from signal shaping to offline evaluation and cold-start fallbacks.

Expected output: A recommendation plan JSON and code to train, score, and evaluate an implicit MF or KNN baseline with clear offline metrics.

• Variations:
  • Add content-based hybridization using item features.
  • Introduce diversity/novelty constraints in ranking.
  • Emit on-demand recommendations for a single user context.

Quick Reference: Prompts, Tasks, and Output Types

Practical usage notes for ChatGPT-5.5 Mini

• When asking for code and execution, include “If Code Interpreter is available, ask permission to run.” This ensures predictable, opt-in execution.
• Always request a JSON block before code. It’s easier to diff across runs, logs, and PRs, and you can fail a CI job on schema mismatches.
• Prefer deterministic outputs: set seeds, sort outputs, and fix top-k values. This makes outputs traceable across environments.
• When in doubt, ask for assumptions-and-risks notes. A 2–3 sentence caveat can save a week of rework.

Example stub for code execution safety

# In your prompt, you can request a permission gate like:
"Before executing any code or reading files, ask: 'Proceed to run with Code Interpreter? (yes/no)'. 
If 'yes', run and print concise results. If 'no', output the code and describe how to run locally."

Chaining prompts for complete analysis workflows

You can combine these prompts into robust pipelines. For instance:

1. Data Cleaning: Run Prompts 1–5 to standardize the dataset, impute missing values, coerce types, detect outliers, and scale features.
2. EDA: Use Prompts 6–10 to surface distributions, correlations, seasonality, cohorts, and candidate segmentations.
3. Transformation: Apply Prompts 11–15 to pivot, compute rolling windows, engineer features, and add calendar terms.
4. Statistical Tests: Deploy Prompts 16–20 for rigorous hypothesis checks, regression with diagnostics, A/B evaluation, bootstrap CIs, and trend tests.
5. Visuals and Reporting: Prompts 21–25 convert findings into accessible chart specs, dashboards, and executive narratives.
6. Advanced Analytics: Prompts 26–30 frame and train predictive models, clustering, anomalies, forecasts, and recommendations.

Here is a compact “chain coordinator” prompt you can adapt:

Role: You are a workflow orchestrator using ChatGPT-5.5 Mini.
Goal: Execute a full analysis chain with audit trails.

Context:
- Data: {file_paths}
- Target and objectives: {target}/{objective}
- Timeline: {timeline}

Instructions:
1) Keep a running "analysis_ledger" JSON with steps, decisions, code hashes, and validation metrics.
2) At each stage (clean → EDA → stats → visuals → modeling), propose next actions; wait for confirmation.
3) For code: if Code Interpreter is available, ask before executing; else, emit scripts with CLI instructions.
4) End with a signed-off executive summary and an exportable HTML/Markdown report with attachments.

Output:
- JSON "analysis_ledger"
- Final summary (Markdown)
- List of generated artifacts with filenames and sizes

As you iterate, keep intermediate JSONs from each prompt (e.g., imputation_plan, distribution_report, correlation_matrix). They form your provenance trail for compliance and knowledge transfer.

FAQ

1) Do these prompts require Code Interpreter to work?

No. Each prompt requests runnable code but also works in “emit only” mode. If your ChatGPT-5.5 Mini environment has Code Interpreter, the prompts ask for permission to execute; otherwise, you can copy the code into your local notebook or CI job. The structure and validation steps remain useful either way.

2) How do I prevent data leakage across these workflows?

Follow the guards embedded in the prompts: fit imputers and scalers only on train splits; use group- or time-aware splits; cross-fit encoders; and keep test folds untouched. Many prompts explicitly warn about leakage and ask for post-step validation. Consider reviewing

For additional context on related AI capabilities and workflows, our comprehensive resource on The Big Prompt Engineering Story: What July 13’s News Means for Developers provides practical guidance and implementation strategies that complement the techniques discussed in this article.

for strategies to encode safeguards into every step.

3) What if my dataset is very large (hundreds of millions of rows)?

Use the warehouse-first variations provided in many prompts (SQL window functions, GROUP BY pivots, in-warehouse correlations). ChatGPT-5.5 Mini can draft SQL that runs close to the data, then you can sample results back into the model for summaries and decisions. Use Spark or Dask variants for distributed transforms when Python is required.

4) Can I adapt these prompts for R or SQL-only environments?

Yes. Nearly all prompts include a variation to emit R (dplyr, data.table, stats) or SQL. Ask explicitly for your dialect (PostgreSQL, BigQuery, Snowflake, Databricks SQL) and request execution plans, indices, and cost notes where relevant.

5) How do I make outputs more deterministic for CI/CD?

Always ask to: set random seeds; sort outputs; fix top-k; stabilize formatting (fixed decimals, column order); and emit JSON schemas first. In CI, you can validate JSON with a schema and diff it across runs. Avoid free-text unless you also request a machine-checkable summary.

6) What about privacy and compliance?

Before uploading data, de-identify PII and apply masking. The prompts encourage you to keep audit tables (deduplication), append-only logs (outlier flags), and explicit assumptions in JSON. You can store these alongside artifacts to support internal reviews or audits.

7) When should I switch from Mini to a larger model?

Use Mini for fast iteration, broad EDA, and drafting code/specs. If you hit complex multimodal reasoning, advanced causal inference, or need richer domain synthesis, consider a flagship model for those specific steps, then return to Mini for execution and iteration to stay cost-effective.

8) How do I integrate these prompts into a team workflow?

Adopt the “analysis ledger” pattern, keep JSON plans in version control, and use the automated report template to publish weekly. Tie code snippets to unit tests and data quality checks. Over time, you’ll standardize your org’s patterns and reduce onboarding friction for new analysts.