30 Production-Ready ChatGPT-5.5 Prompts for Data Analysts

Author: Markos Symeonides. Date: July 10, 2026.

Introduction: Why ChatGPT-5.5 Is Ideal for Data Analysis Workflows

Data analysis demands precision, speed, and clarity. In modern organizations, analysts are expected to transform raw, messy, and often siloed data into crisp insights that move the business forward. ChatGPT-5.5 is particularly well-suited to this challenge. It blends advanced reasoning with strong domain fluency in SQL, Python, statistics, data visualization, and storytelling. When paired with robust data governance and reproducible workflows, it helps analysts reduce friction at every step—from scoping questions and generating complex queries to building high-quality visuals, running sound statistical tests, and turning analysis into crisp executive outputs.

At its core, ChatGPT-5.5 acts like a tireless, context-aware co-pilot. It excels at synthesizing schemas, identifying edge cases, refactoring code for performance, validating assumptions, and codifying best practices into reusable templates. It can produce step-by-step reasoning, comment-rich code, and audit-friendly narratives that explain methods and trade-offs. This means you can go from idea to insight faster, with less rework, while preserving the rigor your stakeholders expect.

In this article you will find 30 production-ready prompts across four pillars of analytics work: SQL Generation, Data Visualization, Statistical Analysis, and Automated Reporting. Each prompt provides structure, guardrails, and clear customization variables, so you can adapt it to your data stack, business context, and organizational standards. Use them as-is or evolve them into your team’s internal playbooks.

For a deeper exploration of this topic, our comprehensive article on The Codex CI/CD Pipeline Playbook: 15 Prompts for Automated Build Systems, Deployment Configurations, and Release Management provides detailed analysis, practical examples, and actionable strategies that complement the concepts discussed in this section.

For a deeper exploration of this topic, our comprehensive article on How to Build a Cybersecurity Vulnerability Scanner with OpenAI Codex provides detailed analysis, practical examples, and actionable strategies that complement the concepts discussed in this section.

For a deeper exploration of this topic, our comprehensive article on The 2026 Prompt Library: 7 Templates for Prompt Engineering provides detailed analysis, practical examples, and actionable strategies that complement the concepts discussed in this section.

Section 1: SQL Generation (8 Prompts)

In data analysis, SQL remains the lingua franca for extracting and shaping data. The following prompts will help you reliably translate business questions into performant SQL, design and evolve schemas, and manage migrations safely across environments. They emphasize input structure, dialect specificity, explainability, and validation.

1) Natural Language to Dialect-Specific SQL with Schema Awareness

When to use: You have a well-defined business question and an existing schema. You want precise, runnable SQL in a specific dialect, with clear assumptions and validation steps. Expected output: A single, well-formatted SQL query aligned to your specified dialect, explanatory notes, indexes or CTE suggestions, and test cases for verification.

Role: Senior Analytics Engineer

Goal: Convert a business question into a correct, performant SQL query tailored to {{SQL_DIALECT}}.

Inputs you will receive:
1) Business question: {{BUSINESS_QUESTION}}
2) Schema DDL or table dictionary (include keys, types, nullability): {{SCHEMA_REFERENCE}}
3) Data constraints and known pitfalls (e.g., duplicates, late arriving events, time zone): {{DATA_NOTES}}
4) Required filters, date range, and audience definition: {{REQUIRED_FILTERS}}
5) Output format and grain (e.g., one row per {{GRAIN}}): {{OUTPUT_GRAIN}}
6) Performance budget (e.g., must run in < {{RUNTIME_BUDGET}} seconds on {{WAREHOUSE}}): {{PERF_BUDGET}}
7) Dialect: {{SQL_DIALECT}} (e.g., BigQuery, Snowflake, Postgres, Redshift, Databricks SQL)

What to produce:
A) Final SQL query:
- Use explicit CTEs with descriptive names.
- Enforce all filters and audience definitions.
- Prefer set-based operations and window functions over cursor-like patterns.
- Annotate tricky logic with inline comments.
- Favor stable ordering and determinism; avoid non-deterministic functions unless requested.

B) Explanation:
- Summarize join strategy, grain alignment, and null-handling choices.
- List any assumptions and how to validate them.
- Suggest meaningful indexes or clustering/partitioning (when applicable).

C) Validation tests (runnable queries):
- Row count and grain checks (e.g., rows per key).
- Spot-check queries for known edge cases (e.g., {{EDGE_CASE_1}}, {{EDGE_CASE_2}}).

D) Optional: a “lite” version if the performance budget is tight.

Important constraints:
- Strictly adhere to the {{SQL_DIALECT}} syntax specifics.
- Do not invent column names; if unknown, ask for a schema update.
- If the question is ambiguous, list clarifying questions first, then provide a best-effort query with flags.

Deliverables:
1) Final SQL (ready to run)
2) Narrative explanation
3) Validation test queries

Customization variables: {{SQL_DIALECT}}, {{BUSINESS_QUESTION}}, {{SCHEMA_REFERENCE}}, {{DATA_NOTES}}, {{REQUIRED_FILTERS}}, {{OUTPUT_GRAIN}}, {{RUNTIME_BUDGET}}, {{WAREHOUSE}}, {{PERF_BUDGET}}, {{EDGE_CASE_1}}, {{EDGE_CASE_2}}

2) Performance Tuning and Index/Partition Recommendations

When to use: You have a working query that is slow or costly and need tactical improvements. Expected output: An optimized query version, rationale for changes, index/partition recommendations, statistics refresh guidance, and expected impact estimates.

Role: SQL Performance Engineer

Goal: Optimize the given {{SQL_DIALECT}} query for latency and/or cost while preserving correctness.

Inputs:
- Current SQL: {{CURRENT_SQL}}
- Table stats (rows, size, cardinality): {{TABLE_STATS}}
- Current indexes/partitions/clustering: {{PHYSICAL_DESIGN}}
- Query plan (if available): {{EXPLAIN_PLAN}}
- SLAs: latency {{LATENCY_SLA}} seconds, budget {{COST_BUDGET}}

What to produce:
A) Optimized query:
- Reorder joins; transform subqueries to CTEs if beneficial.
- Replace inefficient patterns (e.g., SELECT DISTINCT) with alternatives when safe.
- Push filters down to reduce scanned data; use partition pruning.
- Only select necessary columns to minimize I/O.

B) Physical design changes:
- Index recommendations with columns, order, and justification.
- Partitioning or clustering strategy tailored to workload.
- Statistics updates (what and why), plus vacuum/analyze suggestions if relevant.

C) Impact estimates:
- Expected improvement percentages; note assumptions.
- Risks or regression scenarios and rollback plan.

D) Validation:
- Equivalence check SQL to verify result parity with baseline.
- Benchmarking steps: cold vs warm cache, concurrency settings.

Constraints:
- Maintain exact result semantics; call out any lossy changes.
- Be explicit about dialect-specific syntax and features (e.g., QUALIFY in BigQuery).

Deliverables:
1) Revised SQL
2) Physical design recommendations
3) Validation and benchmarking plan
4) Impact summary

Customization variables: {{SQL_DIALECT}}, {{CURRENT_SQL}}, {{TABLE_STATS}}, {{PHYSICAL_DESIGN}}, {{EXPLAIN_PLAN}}, {{LATENCY_SLA}}, {{COST_BUDGET}}

3) Normalized Schema Design from Business Requirements

When to use: You are designing a new data model and need 3NF or star schema from narrative requirements. Expected output: ERD description, table DDLs, keys, constraints, indexing strategy, slowly changing dimensions (if needed), sample data, and migration notes.

Role: Data Modeler

Goal: Translate business requirements into a normalized (3NF) and analytics-friendly schema (plus star-schema variant if appropriate).

Inputs:
- Requirements narrative: {{BUSINESS_REQUIREMENTS}}
- Workloads: OLTP vs OLAP emphasis: {{WORKLOAD_PROFILE}}
- Data volumes and growth: {{VOLUME_PROFILE}}
- Latency/freshness targets: {{FRESHNESS_SLA}}
- Compliance needs (PII, GDPR): {{COMPLIANCE_NOTES}}
- Dialect/warehouse: {{SQL_DIALECT}}

What to produce:
A) Logical model:
- Entities, attributes, relationships, and cardinalities.
- Natural vs surrogate keys; rationale.

B) Physical model (DDL):
- CREATE TABLE statements with types, nullability, defaults, and constraints.
- Primary/foreign keys; unique constraints; check constraints for data quality.
- Index, partition, and clustering recommendations; compression/encoding where relevant.

C) Analytics layer:
- Star schema view with fact and dimension tables.
- Grain definitions and conformed dimensions.
- SCD handling (Type 1/2) for {{DIMENSIONS_REQUIRING_SCD}}.

D) Sample data and queries:
- Minimal INSERT samples for each table.
- Example business questions and SQL queries.

E) Governance:
- Column-level PII tags, masking or tokenization suggestions.
- Data lineage notes and naming conventions.

Deliverables:
1) ERD description (textual)
2) DDL scripts
3) Sample data and example queries
4) Governance and lineage notes

Customization variables: {{BUSINESS_REQUIREMENTS}}, {{WORKLOAD_PROFILE}}, {{VOLUME_PROFILE}}, {{FRESHNESS_SLA}}, {{COMPLIANCE_NOTES}}, {{SQL_DIALECT}}, {{DIMENSIONS_REQUIRING_SCD}}

4) Safe Migration Script Generator (DDL Diff with Rollback)

When to use: You need to evolve a schema across environments and ensure safety, traceability, and rollback. Expected output: Forward migration DDL, rollback scripts, dependency analysis, data backfill/transform steps, and runbook with pre/post checks.

Role: Database Release Engineer

Goal: Create a safe, idempotent migration from current to target schema with rollback.

Inputs:
- Current DDL: {{CURRENT_DDL}}
- Target DDL: {{TARGET_DDL}}
- Data retention policies/sensitivity: {{DATA_POLICIES}}
- Environment(s): {{ENVIRONMENTS}} (e.g., dev, stage, prod)
- Dialect/warehouse: {{SQL_DIALECT}}

What to produce:
A) DDL diff plan:
- Object-by-object changes (tables, views, indexes, constraints).
- Impacted dependencies (views, stored procs, ETL jobs).

B) Forward migration scripts:
- Idempotent CREATE/ALTER statements.
- Online-safe strategies (e.g., create new table + backfill + swap).
- Data transforms/backfills with progress logging.

C) Rollback plan:
- Exact reverse scripts (DROP/RENAME/SWAP).
- Snapshot/backup commands; restore steps.

D) Runbook:
- Pre-checks (row counts, space, locks).
- Execution order with transactional boundaries.
- Post-checks (constraint validation, counts, performance smoke tests).

Constraints:
- Avoid destructive changes without backup or dual-write period.
- Use feature flags or views to minimize downtime when necessary.

Deliverables:
1) Forward migration scripts
2) Rollback scripts
3) Dependency and risk report
4) Ops runbook

Customization variables: {{CURRENT_DDL}}, {{TARGET_DDL}}, {{DATA_POLICIES}}, {{ENVIRONMENTS}}, {{SQL_DIALECT}}

5) Cohort Retention and Window Functions Query Builder

When to use: You need accurate cohorting and retention metrics over time. Expected output: Cohort table SQL with clear definitions, window functions for retention, and optional outputs for visualization (e.g., heatmap-ready).

Role: Product Analytics SQL Specialist

Goal: Generate a robust cohort retention query using window functions in {{SQL_DIALECT}}.

Inputs:
- Event table and columns: {{EVENT_TABLE}} (columns: {{EVENT_COLUMNS}})
- User identifier and signup timestamp: {{USER_ID_COL}}, {{SIGNUP_TS_COL}}
- Activity event and timestamp: {{ACTIVITY_EVENT}}, {{ACTIVITY_TS_COL}}
- Cohort interval (e.g., weekly, monthly): {{COHORT_INTERVAL}}
- Retention definition (e.g., any activity, specific feature use): {{RETENTION_CRITERIA}}
- Time zone and late-arrival policy: {{TIME_ZONE_POLICY}}, {{LATE_ARRIVAL_POLICY}}

What to produce:
A) Final SQL:
- Build cohorts on {{SIGNUP_TS_COL}} truncated to {{COHORT_INTERVAL}}.
- Compute period offsets (e.g., weeks since signup).
- Retained flag per user and period based on {{RETENTION_CRITERIA}}.
- Output: cohort_start, period_index, users_in_cohort, users_retained, retention_rate.

B) Notes:
- Null handling, event de-duplication, and window ordering.
- Efficient partitioning/clustering suggestions.
- Scalability considerations for large user bases.

C) Validation:
- Query for sample cohorts.
- Sanity checks for monotonic cohort sizes and logical retention bounds (0-100%).

Deliverables:
1) Heatmap-ready cohort table SQL
2) Explanation and validation queries

Customization variables: {{SQL_DIALECT}}, {{EVENT_TABLE}}, {{EVENT_COLUMNS}}, {{USER_ID_COL}}, {{SIGNUP_TS_COL}}, {{ACTIVITY_EVENT}}, {{ACTIVITY_TS_COL}}, {{COHORT_INTERVAL}}, {{RETENTION_CRITERIA}}, {{TIME_ZONE_POLICY}}, {{LATE_ARRIVAL_POLICY}}

6) Incremental Upsert/MERGE Model for a Data Warehouse

When to use: You have a large source with late arriving changes and need a robust incremental model. Expected output: MERGE-based SQL (or equivalent), change detection logic, deduplication strategy, keys, and tests.

Role: Warehouse Modeling Expert

Goal: Create an incremental upsert (MERGE) model in {{SQL_DIALECT}} for slowly changing transactional data.

Inputs:
- Source table: {{SOURCE_TABLE}} with columns {{SOURCE_COLUMNS}}
- Target table: {{TARGET_TABLE}}
- Business keys: {{BUSINESS_KEYS}}
- Change capture fields (updated_at, version, hash): {{CHANGE_FIELDS}}
- Late-arrival tolerance window: {{LATE_WINDOW}}
- Deduplication rules: {{DEDUP_RULES}}

What to produce:
A) Incremental SQL:
- Staging CTE for latest record per {{BUSINESS_KEYS}} using window functions.
- Change detection via {{CHANGE_FIELDS}} (timestamp or hash).
- MERGE statement with WHEN MATCHED/WHEN NOT MATCHED logic.
- Optional soft-deletes handling if {{SOFT_DELETE_LOGIC}}.

B) Operational guidance:
- Partitioning and clustering for target.
- Scheduling frequency aligned with {{LATE_WINDOW}}.
- Idempotency and retry strategy.

C) Tests:
- Row-level equivalence and duplicate checks.
- Change-rate monitoring queries.

Deliverables:
1) MERGE SQL
2) Operational notes
3) Test queries

Customization variables: {{SQL_DIALECT}}, {{SOURCE_TABLE}}, {{SOURCE_COLUMNS}}, {{TARGET_TABLE}}, {{BUSINESS_KEYS}}, {{CHANGE_FIELDS}}, {{LATE_WINDOW}}, {{DEDUP_RULES}}, {{SOFT_DELETE_LOGIC}}

7) Data Quality Checks and Guardrail Queries

When to use: You want to operationalize data sanity checks at ingestion or transformation layers. Expected output: A suite of SQL tests for nulls, ranges, referential integrity, duplicates, distribution shifts, and outliers, with thresholds and alerting guidance.

Role: Data Quality Engineer

Goal: Provide a SQL-based data quality test pack for {{DATASET_NAME}} on {{SQL_DIALECT}}.

Inputs:
- Tables and columns to monitor: {{TARGET_TABLES}}
- Business-critical constraints (keys, ranges, enums): {{CONSTRAINTS}}
- Expected distributions and seasonality notes: {{DISTRIBUTION_EXPECTATIONS}}
- Alert thresholds and escalation policy: {{ALERT_POLICY}}

What to produce:
A) Tests:
- Null and missing key checks with row sampling queries.
- Uniqueness checks for {{KEY_COLUMNS}} with duplication detail.
- Referential integrity checks across {{FK_RELATIONSHIPS}}.
- Range and enum validations with exception captures.
- Distribution shift tests (e.g., population stability index or KL divergence) for {{MONITORED_COLUMNS}}.
- Outlier detection via robust stats (IQR/MAD) for numeric fields.

B) Scheduling and alerting:
- Suggested run cadence.
- Thresholds mapped to severity levels.

C) Maintenance:
- Versioning and disabling tests during planned schema changes.

Deliverables:
1) Test SQL pack
2) Alerting/routing suggestions
3) Maintenance guidance

Customization variables: {{SQL_DIALECT}}, {{DATASET_NAME}}, {{TARGET_TABLES}}, {{CONSTRAINTS}}, {{KEY_COLUMNS}}, {{FK_RELATIONSHIPS}}, {{MONITORED_COLUMNS}}, {{DISTRIBUTION_EXPECTATIONS}}, {{ALERT_POLICY}}

8) Cross-Database SQL Translation and Equivalence Validation

When to use: You are porting logic between warehouses and need precise dialect translation and validation. Expected output: Translated SQL, a compatibility report, gaps and workarounds, and equivalence tests with sample data.

Role: SQL Portability Specialist

Goal: Translate the provided SQL from {{SOURCE_DIALECT}} to {{TARGET_DIALECT}} and prove equivalence.

Inputs:
- Source SQL: {{SOURCE_SQL}}
- Feature usage notes (functions, types, window specs): {{FEATURE_NOTES}}
- Source/target schema differences: {{SCHEMA_DIFFS}}
- Test data or sampling approach: {{TEST_DATA_PLAN}}

What to produce:
A) Translated SQL:
- One-to-one translation wherever possible.
- Clear comments for non-trivial rewrites and function substitutes.

B) Compatibility report:
- Unsupported features in {{TARGET_DIALECT}} and recommended workarounds.
- Type mapping table and precision/scale implications.

C) Equivalence validation:
- Test harness SQL to compare outputs row-by-row on {{TEST_DATA_PLAN}}.
- Tolerance settings for floating-point differences.

Deliverables:
1) Target-dialect SQL
2) Compatibility and risk report
3) Validation queries

Customization variables: {{SOURCE_DIALECT}}, {{TARGET_DIALECT}}, {{SOURCE_SQL}}, {{FEATURE_NOTES}}, {{SCHEMA_DIFFS}}, {{TEST_DATA_PLAN}}

Section 2: Data Visualization (7 Prompts)

Visuals should tell a truthful story with the least cognitive load. The prompts below help you pick the right chart, generate clean Python/matplotlib or Plotly code, encode intent with color and annotation, and design dashboards that scale from exploratory views to executive snapshots.

9) Chart Type Recommender with Encodings and Pitfall Checks

When to use: You need guidance on chart selection based on data shape, analytical task, and audience. Expected output: Recommended chart types with mark/encoding choices, rationale, accessibility checks, and anti-pattern warnings.

Role: Data Visualization Strategist

Goal: Recommend chart(s) and encodings aligned to the analytical task and audience.

Inputs:
- Analytical question: {{ANALYTICAL_QUESTION}}
- Data summary (variables, types, cardinality, sample stats): {{DATA_SUMMARY}}
- Audience (execs, PMs, engineers), medium (slide, dashboard, mobile): {{AUDIENCE_CONTEXT}}
- Constraints (brand colors, color-vision safe requirement): {{VIZ_CONSTRAINTS}}

What to produce:
A) Chart recommendations:
- Primary and alternative chart(s) with marks, encodings (x, y, color, size, shape), and faceting if relevant.
- Ordering, binning, and scale (linear/log) decisions.
- Labeling and annotation plan.

B) Rationale:
- Task alignment: compare, rank, part-to-whole, distribution, relationship, change-over-time.
- Potential pitfalls (e.g., 3D, dual-axis misuse, cherry-picked baselines).
- Accessibility: colorblind-safe palettes, texture/shape redundancy.

C) Ready-to-implement spec:
- Data transforms required (aggregation, filtering).
- Suggested figure size and aspect ratio for {{MEDIUM}}.
- Export format recommendations (SVG/PNG/PDF).

Deliverables:
1) Chart(s) + encoding spec
2) Rationale and pitfalls
3) Implementation notes

Customization variables: {{ANALYTICAL_QUESTION}}, {{DATA_SUMMARY}}, {{AUDIENCE_CONTEXT}}, {{VIZ_CONSTRAINTS}}, {{MEDIUM}}

10) Matplotlib/Seaborn Plot Generator with Clean Defaults

When to use: You want production-quality Python plotting code with consistent styles and documentation. Expected output: A Python script using matplotlib/seaborn that includes styling, titles, labels, color-safe palette, annotations, and save/export logic.

Role: Python Visualization Engineer

Goal: Produce clean, reproducible matplotlib/seaborn code for the described plot(s).

Inputs:
- DataFrame name and schema: {{DF_NAME}} with {{DF_SCHEMA}}
- Plot type(s) and purpose: {{PLOT_PURPOSE}}
- Branding and style (font, palette, grid): {{STYLE_GUIDE}}
- Output specs (dpi, size, file paths): {{EXPORT_SPECS}}

What to produce:
A) Python code:
- Imports, seed setting, and style initialization (e.g., seaborn.set_theme).
- Data preparation steps (filtering, grouping, sorting).
- Plot(s) with titles, subtitles, axis labels, tick formatting.
- Colorblind-safe palette and legend placement.
- Annotations for key points, thresholds, or targets.
- Tight layout and export to multiple formats (PNG/SVG/PDF).
- Optional: function-wrapped plotting for reuse.

B) Commentary:
- Justify key style choices and how to adapt them.
- Notes on performance with large datasets.

Deliverables:
1) Executable Python code block
2) Brief implementation notes

Customization variables: {{DF_NAME}}, {{DF_SCHEMA}}, {{PLOT_PURPOSE}}, {{STYLE_GUIDE}}, {{EXPORT_SPECS}}

11) Plotly/Dash Interactive Dashboard Scaffold

When to use: You need a minimal viable interactive dashboard for exploration or stakeholder demos. Expected output: A Plotly Dash app skeleton with layout, callbacks, filters, and performance notes.

Role: Analytics App Prototyper

Goal: Create a Plotly Dash scaffolding for an interactive dashboard.

Inputs:
- Data source and loading method: {{DATA_SOURCE}}
- Key views (e.g., KPIs, time series, segmentation): {{KEY_VIEWS}}
- Interactions (filters, selectors, brush/zoom): {{INTERACTIONS}}
- Performance constraints (max rows, pre-aggregation notes): {{PERF_NOTES}}
- Branding and layout preferences: {{BRAND_LAYOUT}}

What to produce:
A) Dash app code:
- App initialization with external styles for {{BRAND_LAYOUT}}.
- Layout with responsive grid, navigation tabs, and placeholders.
- Data loading strategy; caching or pre-aggregation as needed.
- Callbacks connecting filters to charts/tables.
- Sensible defaults and safeguards for large data.
- Export/share controls (CSV download, image export).

B) Documentation:
- Instructions for running locally and deploying to {{HOST_ENV}}.
- How to extend charts and filters.

Deliverables:
1) Minimal Dash app code
2) Setup and deployment notes

Customization variables: {{DATA_SOURCE}}, {{KEY_VIEWS}}, {{INTERACTIONS}}, {{PERF_NOTES}}, {{BRAND_LAYOUT}}, {{HOST_ENV}}

12) Storytelling with Data: Narrative + Annotations Plan

When to use: You want a coherent narrative that connects facts to decisions using well-placed annotations and callouts. Expected output: A storyline outline, key message hierarchy, annotation plan, and a do/don’t checklist.

Role: Data Storytelling Coach

Goal: Craft a narrative arc and annotation strategy for the analysis.

Inputs:
- Audience and decision context: {{DECISION_CONTEXT}}
- Key findings and uncertainties: {{KEY_FINDINGS}}
- Risks, caveats, and assumptions: {{ASSUMPTIONS}}
- Visual assets available or planned: {{VISUAL_ASSETS}}
- Time allotted for presentation: {{TIME_BUDGET}}

What to produce:
A) Narrative structure:
- One-sentence takeaway and 3 supporting points.
- Flow: context → insight → implication → recommendation → next steps.
- Questions to anticipate and where to address them.

B) Annotation plan:
- Exact labels, arrows, thresholds, and reference lines to add.
- Spotlight key comparisons and define baselines.
- Minimize chartjunk; emphasize signal over noise.

C) Checklist:
- Executive readability in {{TIME_BUDGET}}.
- Accessibility (color-vision, font sizes).
- Rehearsal prompts and backup slides.

Deliverables:
1) Narrative outline
2) Annotation blueprint
3) Presenter checklist

Customization variables: {{DECISION_CONTEXT}}, {{KEY_FINDINGS}}, {{ASSUMPTIONS}}, {{VISUAL_ASSETS}}, {{TIME_BUDGET}}

13) Color Systems and Branding-Compliant Palettes

When to use: You need a color scheme that is accessible, brand-compliant, and expressive for your charts. Expected output: Primary and fallback palettes, semantic color mappings for KPI states, and usage guidance.

Role: Visualization Accessibility Specialist

Goal: Define accessible, brand-compliant color palettes and mappings.

Inputs:
- Brand primary/secondary colors (hex/rgb): {{BRAND_COLORS}}
- Accessibility requirements (contrast ratios): {{ACCESSIBILITY_REQS}}
- Chart types and number of series: {{SERIES_NEEDS}}
- KPI semantics (good, bad, neutral): {{KPI_SEMANTICS}}

What to produce:
A) Palettes:
- Sequential, diverging, categorical palettes with hex codes.
- Colorblind-safe variants and grayscale fallbacks.

B) Mappings and rules:
- Assign semantics to consistent colors (e.g., good=green, bad=red with patterns).
- Usage limits (max categories before confusion).

C) Implementation:
- Snippets for matplotlib, seaborn, Plotly.
- Documentation for internal style guide.

Deliverables:
1) Palette definitions
2) Semantic mapping rules
3) Implementation snippets

Customization variables: {{BRAND_COLORS}}, {{ACCESSIBILITY_REQS}}, {{SERIES_NEEDS}}, {{KPI_SEMANTICS}}

14) Distribution and Density Visualization Planner

When to use: You are exploring distributions and need to choose between histograms, KDE, ECDF, box/violin, ridgelines, etc. Expected output: Recommended plots with binning/smoothing guidance, handling of heavy tails/outliers, and small-multiples strategy.

Role: Exploratory Data Analyst

Goal: Plan the right distribution visualizations for {{VARIABLES_OF_INTEREST}}.

Inputs:
- Variables and types: {{VARIABLES_OF_INTEREST}}
- Sample size and skew/outliers notes: {{DISTRIBUTION_NOTES}}
- Comparison groups/segments: {{GROUPS}}
- Analysis goals (compare, detect skew, tail risk): {{GOALS}}

What to produce:
A) Plot plan:
- For univariate: histogram/ECDF/KDE with binning/bandwidth selection.
- For multigroup: small multiples or ridgeline plots.
- For outliers: box/violin with robust statistics.

B) Parameters:
- Bin width via Freedman–Diaconis or Scott rules when relevant.
- KDE bandwidth and kernel choice with caution on multimodality.

C) Implementation notes:
- Sample vs full data strategies.
- Overlay fits or reference distributions as needed.

Deliverables:
1) Plot recommendations
2) Parameterization guide
3) Implementation notes (Python/Plotly snippets optional)

Customization variables: {{VARIABLES_OF_INTEREST}}, {{DISTRIBUTION_NOTES}}, {{GROUPS}}, {{GOALS}}

15) Dashboard QA and Performance Hardening Checklist

When to use: Before shipping a dashboard to stakeholders. Expected output: A QA checklist covering correctness, performance, usability, governance, and run-time monitoring.

Role: Analytics QA Lead

Goal: Provide a comprehensive QA checklist and hardening plan for the dashboard.

Inputs:
- Data sources and refresh cadence: {{REFRESH_CADENCE}}
- Critical metrics and definitions: {{METRICS_DEFS}}
- Interactions and filters: {{FILTERS_INTERACTIONS}}
- Performance SLOs (load time, query budget): {{PERF_SLOS}}
- Access and governance (RBAC, PII): {{GOVERNANCE}}

What to produce:
A) QA checklist:
- Data correctness (definitions, unit tests for transforms).
- Visual correctness (labels, scales, legends).
- Interaction correctness (cross-filter behavior).

B) Performance:
- Query optimization, caching, pre-aggregation.
- Async loading patterns and skeleton UI.
- Error handling and graceful degradation.

C) Governance and reliability:
- RBAC and row-level security tests.
- Audit logging and lineage references.
- Monitoring, alerting on refresh failures.

Deliverables:
1) Checklist
2) Hardening recommendations
3) Monitoring plan

Customization variables: {{REFRESH_CADENCE}}, {{METRICS_DEFS}}, {{FILTERS_INTERACTIONS}}, {{PERF_SLOS}}, {{GOVERNANCE}}

Section 3: Statistical Analysis (8 Prompts)

Rigorous statistical reasoning is crucial for credible analytics. These prompts help you choose appropriate tests, size experiments, build models with defensible assumptions, detect anomalies, and evaluate uncertainty. Each prompt emphasizes assumptions, diagnostics, and transparent reporting.

16) Hypothesis Test Selector and Analysis Plan

When to use: You need to select the right test and produce a replicable plan. Expected output: Test recommendation, assumptions, step-by-step procedure, effect size metrics, and interpretation template.

Role: Statistical Analyst

Goal: Select and execute an appropriate hypothesis test with a clear analysis plan.

Inputs:
- Research question and hypotheses: {{HYPOTHESES}}
- Outcome type (continuous, binary, count) and distribution notes: {{OUTCOME_TYPE}}
- Groups/comparisons and sample sizes: {{GROUPS_SAMPLES}}
- Assumptions (normality, independence) and violations: {{ASSUMPTIONS_NOTES}}
- Significance level and power target: {{ALPHA_POWER}}

What to produce:
A) Test selection:
- Recommended test(s) with justification (e.g., Welch t-test, Mann–Whitney U, chi-square, Fisher, ANOVA, Kruskal–Wallis).
- Parametric/nonparametric decision.

B) Analysis plan:
- Data preprocessing, transformation (log, Box–Cox) if needed.
- Assumption checks (normality tests, variance homogeneity).
- Primary and sensitivity analyses.

C) Reporting:
- Effect sizes (Cohen’s d, odds ratio, CIs).
- p-values with interpretation limits.
- Practical significance and recommendations.

Deliverables:
1) Chosen test(s) with rationale
2) Procedure and diagnostic checks
3) Reporting template with example language

Customization variables: {{HYPOTHESES}}, {{OUTCOME_TYPE}}, {{GROUPS_SAMPLES}}, {{ASSUMPTIONS_NOTES}}, {{ALPHA_POWER}}

17) Regression Modeling Blueprint (Linear/Logistic/Poisson) with Diagnostics

When to use: You need a vetted regression plan, from variable selection to diagnostics and interpretation. Expected output: Model formula, preprocessing steps, diagnostics plan, multicollinearity checks, and reporting template.

Role: Applied Statistician

Goal: Specify a regression model appropriate for {{OUTCOME_SPEC}} with diagnostics and interpretation.

Inputs:
- Outcome and candidate predictors: {{PREDICTORS_INFO}}
- Data scale, missingness, and outliers: {{DATA_QUALITY_NOTES}}
- Confounders and interactions to consider: {{CONFOUNDERS_INTERACTIONS}}
- Model goals (explanatory vs predictive): {{MODEL_GOALS}}

What to produce:
A) Model blueprint:
- Family/link (Gaussian/identity, Binomial/logit, Poisson/log).
- Formula with interactions and confounder adjustments.
- Preprocessing: scaling, encoding, imputation strategy.

B) Diagnostics:
- Residual analysis, heteroskedasticity tests, influence points (Cook’s D).
- Multicollinearity (VIF), separation issues for logistic.
- Goodness-of-fit and calibration.

C) Reporting:
- Coefficients with CIs, effect interpretation in natural units.
- Validation approach (train/test or CV).
- Limitations and sensitivity analyses.

Deliverables:
1) Modeling plan
2) Diagnostics checklist
3) Reporting and validation template

Customization variables: {{OUTCOME_SPEC}}, {{PREDICTORS_INFO}}, {{DATA_QUALITY_NOTES}}, {{CONFOUNDERS_INTERACTIONS}}, {{MODEL_GOALS}}

18) A/B Test Power and Sample Size Calculator Plan

When to use: You need to size an experiment given baseline rates and minimum detectable effect (MDE). Expected output: Sample size per group, duration estimate, assumptions, and sensitivity table.

Role: Experiment Designer

Goal: Compute sample size and power for an A/B test with clear assumptions.

Inputs:
- Metric type (proportion, mean, rate) and baseline: {{METRIC_BASELINE}}
- MDE (absolute or relative): {{MDE}}
- Alpha and power targets: {{ALPHA_TARGET}}, {{POWER_TARGET}}
- Variability estimates (std dev or pooled variance): {{VARIABILITY}}
- Traffic constraints and allocation ratio: {{TRAFFIC_INFO}}

What to produce:
A) Sample size calculations:
- Per group n with formulas and references.
- Adjustments for unequal allocation or clustering.

B) Duration estimate:
- Using traffic rates in {{TRAFFIC_INFO}}, include realistic buffers.

C) Sensitivity:
- Table of n vs MDE vs power.
- Notes on noncompliance, novelty effects, and guardrail metrics.

Deliverables:
1) Sample size per group
2) Duration plan
3) Sensitivity table and caveats

Customization variables: {{METRIC_BASELINE}}, {{MDE}}, {{ALPHA_TARGET}}, {{POWER_TARGET}}, {{VARIABILITY}}, {{TRAFFIC_INFO}}

19) Causal Inference Outline: Difference-in-Differences (DiD)

When to use: You have observational before/after data with treated and control groups. Expected output: Identification strategy, model specification, parallel trends checks, placebo tests, and robustness plan.

Role: Causal Analyst

Goal: Plan a credible DiD analysis for {{INTERVENTION_CONTEXT}}.

Inputs:
- Treatment timing and assignment mechanism: {{TREATMENT_DETAILS}}
- Treated and control unit definitions: {{UNIT_DEFINITIONS}}
- Outcome(s) and covariates: {{OUTCOMES_COVARS}}
- Pre-period length and data frequency: {{PRE_PERIOD_INFO}}
- Threats to validity: {{VALIDITY_THREATS}}

What to produce:
A) Identification strategy:
- Assumptions (parallel trends) and diagnostics.
- Event study specification for dynamic effects.

B) Model:
- Two-way fixed effects vs staggered adoption considerations.
- Covariate adjustment, clustering of standard errors.

C) Robustness:
- Placebo tests, alternative controls, pre-trend slope tests.
- Sensitivity to sample windows.

Deliverables:
1) DiD plan with formulas
2) Diagnostic checklist
3) Reporting and visualization plan (event study plots)

Customization variables: {{INTERVENTION_CONTEXT}}, {{TREATMENT_DETAILS}}, {{UNIT_DEFINITIONS}}, {{OUTCOMES_COVARS}}, {{PRE_PERIOD_INFO}}, {{VALIDITY_THREATS}}

20) Time Series Forecasting Plan (ARIMA/SARIMAX/ETS)

When to use: You need a principled path from data exploration to forecast with uncertainty. Expected output: Stationarity checks, decomposition, model candidates, cross-validation scheme, and forecast communication template.

Role: Time Series Specialist

Goal: Design a robust forecasting workflow for {{SERIES_DESCRIPTION}}.

Inputs:
- Series metadata (frequency, seasonality hints, missingness): {{SERIES_META}}
- History length and domain events: {{HISTORY_NOTES}}
- Exogenous regressors (if any): {{EXOG_VARS}}
- Forecast horizon and update cadence: {{HORIZON_UPDATE}}

What to produce:
A) Exploration:
- Decomposition (trend/seasonal/resid).
- Stationarity and unit root tests; differencing plan.
- Anomaly cleaning and imputation strategy.

B) Modeling:
- Candidate models (ARIMA/SARIMA/SARIMAX, ETS, TBATS) with selection criteria (AIC/BIC, CV).
- Cross-validation approach (rolling-origin).
- Hyperparameter search bounds.

C) Output:
- Forecast with prediction intervals.
- Backtest metrics (MAE, MAPE, RMSE).
- Communication tips for uncertainty.

Deliverables:
1) Forecasting plan
2) Candidate models and selection rationale
3) Reporting template with uncertainty

Customization variables: {{SERIES_DESCRIPTION}}, {{SERIES_META}}, {{HISTORY_NOTES}}, {{EXOG_VARS}}, {{HORIZON_UPDATE}}

21) Anomaly Detection Strategy (Statistical + Practical)

When to use: Monitoring KPIs or streams for unusual behavior. Expected output: Choice of detection method(s), thresholding strategy, evaluation plan, and playbook for triage and root cause hints.

Role: Monitoring Analyst

Goal: Define an anomaly detection and triage strategy for {{METRICS_TO_MONITOR}}.

Inputs:
- Metric definitions and seasonality: {{METRIC_DEFS}}
- Data cadence and known change points: {{CADENCE_EVENTS}}
- Cost of false positives vs false negatives: {{COST_TRADEOFFS}}
- Latency and alerting requirements: {{ALERTING_REQS}}

What to produce:
A) Detection:
- Methods (ESD/Generalized ESD, STL+IQ, robust z-score, Prophet/ARIMA residuals).
- Seasonality handling and holiday adjustments.

B) Thresholding:
- Static vs dynamic, percentile or sigma rules, FDR control options.
- Multi-signal confirmation to reduce false positives.

C) Evaluation and operations:
- Backtesting with labeled incidents (if available).
- Alert routing, escalation, and mute logic.
- RCA starter queries/dashboards.

Deliverables:
1) Detection and threshold plan
2) Backtest/evaluation approach
3) Ops runbook for anomalies

Customization variables: {{METRICS_TO_MONITOR}}, {{METRIC_DEFS}}, {{CADENCE_EVENTS}}, {{COST_TRADEOFFS}}, {{ALERTING_REQS}}

22) Survival/Churn Analysis Plan (Kaplan–Meier/Cox PH)

When to use: Modeling time-to-event such as churn or failure. Expected output: Cohort definition, censoring logic, Kaplan–Meier estimates, Cox PH model specification, proportional hazards checks, and interpretation guide.

Role: Customer Analytics Statistician

Goal: Build a survival analysis plan for {{EVENT_OF_INTEREST}}.

Inputs:
- Entry definition and start time: {{ENTRY_RULES}}
- Event definition and censoring rules: {{EVENT_CENSORING}}
- Covariates and segments: {{COVARIATES_SEGMENTS}}
- Observation window and truncation notes: {{OBS_WINDOW}}

What to produce:
A) Nonparametric:
- Kaplan–Meier curves by segment with CIs.
- Log-rank tests for group differences.

B) Semiparametric:
- Cox PH model with covariates; proportional hazards diagnostics (Schoenfeld).
- Time-varying covariates if needed.

C) Reporting:
- Median survival times and hazard ratios with CIs.
- Practical recommendations for retention.

Deliverables:
1) Survival analysis plan
2) Diagnostics and validation steps
3) Reporting template with visuals

Customization variables: {{EVENT_OF_INTEREST}}, {{ENTRY_RULES}}, {{EVENT_CENSORING}}, {{COVARIATES_SEGMENTS}}, {{OBS_WINDOW}}

23) Bootstrap Confidence Intervals and Robust Inference

When to use: Distributional assumptions are weak or sample sizes are moderate. Expected output: Bootstrap plan (resampling scheme), CI type, iteration counts, and reporting guidance.

Role: Robust Inference Specialist

Goal: Provide a bootstrap-based inference plan for {{ESTIMAND}}.

Inputs:
- Statistic/estimand (mean, median, quantile, difference): {{ESTIMAND}}
- Data structure (iid, clustered, time-dependent): {{DATA_STRUCTURE}}
- Sample size and constraints: {{SAMPLE_CONSTRAINTS}}
- Desired precision and runtime budget: {{PRECISION_RUNTIME}}

What to produce:
A) Resampling scheme:
- IID, block bootstrap, or cluster bootstrap as appropriate.
- Number of resamples and seed control for reproducibility.

B) CIs and bias correction:
- Percentile, BCa, or studentized intervals; justification.

C) Reporting:
- Point estimate, CI, and visualization (bootstrap distribution).
- Sensitivity to resample count.

Deliverables:
1) Bootstrap plan
2) Implementation notes (Python/R pseudocode)
3) Reporting template

Customization variables: {{ESTIMAND}}, {{DATA_STRUCTURE}}, {{SAMPLE_CONSTRAINTS}}, {{PRECISION_RUNTIME}}

Section 4: Automated Reporting (7 Prompts)

Automated reporting bridges analysis and action. These prompts focus on executive-ready summaries, weekly updates, KPI dashboards, stakeholder presentations, and alerting content that remains accurate, readable, and trustworthy.

24) Executive Summary Generator from Tables and KPIs

When to use: You have fresh KPIs and need a crisp narrative for executives. Expected output: A 150–250 word summary with trends, drivers, risk flags, and next steps, plus a glossary of metric definitions.

Role: Executive Reporting Writer

Goal: Turn the latest KPI snapshot into a concise, decision-focused summary.

Inputs:
- KPI table(s) and time window: {{KPI_TABLES}}
- Highlights and anomalies: {{HIGHLIGHTS}}
- Strategic priorities this period: {{STRATEGIC_CONTEXT}}
- Risks and dependencies: {{RISKS_DEPENDENCIES}}
- Audience and tone: {{AUDIENCE_TONE}}

What to produce:
A) Summary (150–250 words):
- Lead with the single most important movement.
- Quantify deltas vs last period and vs target.
- Attribute likely drivers and note uncertainties.
- Recommend 2–3 actions or decisions.

B) Appendix:
- KPI definition glossary and calculation notes.
- Data freshness timestamp and caveats.

Deliverables:
1) Executive summary
2) Glossary and freshness note

Customization variables: {{KPI_TABLES}}, {{HIGHLIGHTS}}, {{STRATEGIC_CONTEXT}}, {{RISKS_DEPENDENCIES}}, {{AUDIENCE_TONE}}

25) Weekly Operations Report Template (Automatable)

When to use: Produce a weekly, rolling operational report. Expected output: Structured sections with KPIs, trends, incidents, actions, and a templated narrative that can be automated.

Role: Operations Reporting Lead

Goal: Create a repeatable weekly ops report structure that can be automated.

Inputs:
- Core KPIs with targets: {{CORE_KPIS}}
- Incidents and resolutions: {{INCIDENT_LOG}}
- Initiatives and milestones: {{INITIATIVES}}
- Data freshness and known gaps: {{DATA_FRESHNESS}}
- Audience (ops leads, execs) and distribution channel: {{DISTRIBUTION}}

What to produce:
A) Report blueprint:
- Summary page with KPI table and sparkline trends.
- Incident summary with MTTR, root cause, and prevention actions.
- Initiative status with on-track/at-risk flags.

B) Narrative template:
- Fill-in-the-blanks structure using latest numbers.
- Standard language for uncertainty and dependencies.

C) Automation notes:
- Data pulls, schedule, ownership, and QA checks.
- Export formats (PDF/HTML/Slack) per {{DISTRIBUTION}}.

Deliverables:
1) Report structure
2) Narrative template
3) Automation playbook

Customization variables: {{CORE_KPIS}}, {{INCIDENT_LOG}}, {{INITIATIVES}}, {{DATA_FRESHNESS}}, {{DISTRIBUTION}}

26) KPI Dashboard Spec: Metric Definitions, SQL, and Visuals

When to use: Designing or refactoring a KPI dashboard. Expected output: Metric definitions with ownership, source-of-truth SQL, visualization spec, thresholds, and alerts.

Role: KPI Systems Architect

Goal: Define a robust, governed KPI dashboard specification.

Inputs:
- KPI list with owners and targets: {{KPI_LIST}}
- Data sources and lineage: {{DATA_LINEAGE}}
- Consumers and SLAs: {{CONSUMERS_SLAS}}
- Warehouse and BI tool: {{STACK}}

What to produce:
A) Metric cards:
- Names, definitions, owners, update frequency.
- Source tables and canonical SQL for each metric.

B) Visualization spec:
- Charts per KPI with thresholds/targets.
- Segmentation and drill paths.

C) Governance:
- Change management policy and versioning.
- Alert thresholds and routing.

Deliverables:
1) KPI specification
2) SQL snippets
3) Visualization and alerting plan

Customization variables: {{KPI_LIST}}, {{DATA_LINEAGE}}, {{CONSUMERS_SLAS}}, {{STACK}}

27) Stakeholder Presentation Outline (Problem → Insight → Action)

When to use: Presenting findings to cross-functional stakeholders. Expected output: Slide-by-slide outline, key visuals, speaking notes, and a decision log.

Role: Stakeholder Communications Lead

Goal: Create a high-impact presentation outline that drives decisions.

Inputs:
- Business problem and goals: {{BUSINESS_PROBLEM}}
- Data sources and methods used: {{METHODS}}
- Key findings and recommendations: {{KEY_TAKEAWAYS}}
- Risks, limitations, and next steps: {{RISKS_LIMITS}}

What to produce:
A) Outline:
- Opening: problem framing and success criteria.
- Evidence: 3–5 core visuals with annotations.
- Recommendations: prioritized with expected impact.

B) Notes:
- Anticipated objections and prepared responses.
- Decision log template with owners and timelines.

Deliverables:
1) Slide outline
2) Visuals and notes plan
3) Decision log template

Customization variables: {{BUSINESS_PROBLEM}}, {{METHODS}}, {{KEY_TAKEAWAYS}}, {{RISKS_LIMITS}}

28) Automated Commentary for Metric Movements

When to use: You want machine-generated narrative explaining week-over-week changes. Expected output: Plain-language commentary with attribution, seasonality notes, and confidence flags.

Role: Automated Insights Writer

Goal: Generate accurate, non-hallucinated commentary for metric changes.

Inputs:
- Metric time series and segments: {{METRIC_SERIES}}
- Attribution candidates (dimensions, events): {{ATTRIBUTION_DIMENSIONS}}
- Seasonality/holiday calendar: {{SEASONALITY_CALENDAR}}
- Confidence thresholds and guardrails: {{CONFIDENCE_RULES}}

What to produce:
A) Commentary:
- Lead with absolute and relative changes vs prior and vs target.
- Attribute changes to top contributing segments with evidence.
- Flag seasonal or calendar-driven patterns.

B) Guardrails:
- Only report attributions that cross confidence thresholds.
- Include “insufficient evidence” statements where needed.

C) Output formats:
- Short form (1–2 sentences) and long form (3–5 sentences).
- JSON payload with fields: metric, period, delta_abs, delta_pct, drivers[], confidence.

Deliverables:
1) Human-readable commentary
2) JSON template for programmatic use
3) Confidence and guardrail notes

Customization variables: {{METRIC_SERIES}}, {{ATTRIBUTION_DIMENSIONS}}, {{SEASONALITY_CALENDAR}}, {{CONFIDENCE_RULES}}

29) Alerting Rules and Notification Templates

When to use: Implementing operational alerts for KPIs or pipelines. Expected output: Rule definitions, thresholds, cooldowns, severity mapping, and message templates tailored to channels.

Role: Analytics SRE

Goal: Define robust alerting rules and messages for {{ALERT_DOMAIN}}.

Inputs:
- Metrics/pipelines to monitor: {{MONITORED_ITEMS}}
- Threshold logic and dependencies: {{THRESHOLD_LOGIC}}
- Channels (email, Slack, PagerDuty) and recipients: {{CHANNELS_RECIPIENTS}}
- On-call rotation and escalation: {{ONCALL_ROTATION}}

What to produce:
A) Rules:
- Conditions, thresholds, and cooldowns.
- Correlation and suppression logic to avoid alert storms.

B) Templates:
- Channel-specific messages with context, runbook links, and snapshot data.
- Severity ladder and expected response time.

C) Operations:
- Testing plan (synthetic alerts).
- Post-incident review template.

Deliverables:
1) Alert rule set
2) Notification templates
3) Ops testing and review plan

Customization variables: {{ALERT_DOMAIN}}, {{MONITORED_ITEMS}}, {{THRESHOLD_LOGIC}}, {{CHANNELS_RECIPIENTS}}, {{ONCALL_ROTATION}}

30) Data Catalog and Lineage Doc Generator

When to use: You need to document datasets, columns, owners, refreshes, and upstream/downstream links. Expected output: A catalog in table form plus lineage diagrams (described), quality SLA, and change management notes.

Role: Data Governance Steward

Goal: Produce a clear data catalog and lineage documentation for {{CATALOG_SCOPE}}.

Inputs:
- Tables/views and descriptions: {{ASSET_LIST}}
- Owners, stewards, and SLAs: {{OWNERS_SLAS}}
- Upstream/downstream dependencies: {{LINEAGE_INFO}}
- Quality checks and contracts: {{QUALITY_CONTRACTS}}

What to produce:
A) Catalog:
- For each asset: name, description, owner, SLA, refresh, key columns, PII flags.
- Column dictionary with types and definitions.

B) Lineage:
- Upstream and downstream mappings with brief transformation notes.
- Known risks and fallback paths.

C) Governance:
- Change control, deprecation policy, and contact routes.

Deliverables:
1) Catalog table(s)
2) Lineage description
3) Governance notes

Customization variables: {{CATALOG_SCOPE}}, {{ASSET_LIST}}, {{OWNERS_SLAS}}, {{LINEAGE_INFO}}, {{QUALITY_CONTRACTS}}

Comparative Reference Tables

The following quick-reference tables summarize core choices analysts make daily, mapping data tasks to outputs, and providing a concise cheat sheet for test and chart selection. Use these to orient your workflow quickly and to communicate choices to peers.

Table A: Task-to-Output Reference

Table B: Statistical Test Selection Quick Guide

Table C: Chart Selection Cheat Sheet

Tips for Effective Use with Data Workflows

• Scope ruthlessly. Supply ChatGPT-5.5 with the exact schema, business question, and constraints. The richer your inputs, the closer the outputs will be to production-grade on the first pass.
• Pin the dialect. Always specify the SQL dialect or analytics stack (e.g., BigQuery vs Snowflake vs Postgres), and note any platform features you rely on (QUALIFY, MERGE semantics, time travel).
• Demand explainability. Ask for reasoning, assumptions, and validation checks. Keep these artifacts in your pull requests and documentation for auditability.
• Iterate with small diffs. For query tuning and modeling changes, request minimal diffs from ChatGPT-5.5 to ease code review and reduce regression risk.
• Enforce naming and style guides. Provide your team’s standards for SQL CTE names, Python style, visualization palettes, and dashboard components. Consistency breeds trust.
• Validate with test data. Include sample inputs/outputs, and ask for spot-check queries. For cross-dialect translation, use a formal equivalence harness on a stratified sample.
• Separate exploratory from production. Use prompts tuned for exploration when ideating, then refactor with production prompts for clean, documented, unit-tested outputs.
• Elevate governance. Integrate PII flags, masking suggestions, lineage notes, and ownership into your prompts. Treat governance as a first-class deliverable.
• Right-size complexity. Prefer simple, maintainable solutions unless the problem truly needs complex modeling. Ask ChatGPT-5.5 to present a “lite” version alongside a “full” version.
• Close the loop with monitoring. For dashboards and KPIs, request alert rules, error handling, and post-incident templates. Operability is part of quality.
• Use templates as contracts. These prompts double as contracts between analysts and stakeholders. Customize variables, check them into your repo, and evolve them via code review.
• Benchmark and document. For performance work, collect baseline metrics and compare improved versions. Include EXPLAIN plans and costs to justify changes.
• Design for accessibility. Ask for colorblind-safe palettes, sufficient contrast, and descriptive alt text/captions. Clear design expands your audience.
• Quantify uncertainty. For statistical and forecasting prompts, include confidence intervals, backtest metrics, and assumptions. Decision-makers need ranges, not just points.
• Automate responsibly. Start with a manual dry run of automated reports to calibrate tone, thresholds, and cadence, then harden the pipeline with checks and alerts.

Conclusion

Data analysts thrive when their tools lower friction, enforce best practices, and encourage clarity. ChatGPT-5.5 is a force multiplier for that mission. The 30 prompts above operationalize the craft—from high-signal SQL and defensible statistics to clear visuals and dependable reporting. They encode domain wisdom as checklists, output schemas, and narrative templates, helping you move faster without sacrificing rigor.

Adopt them as living templates. Start by customizing the variables for your schema, stack, and organizational standards. Then integrate them into your repository, your BI guidelines, and your training materials. As your data landscape grows and your questions evolve, refine these prompts in small, reviewable steps. The payoff is compounding: cleaner code, faster insights, better decisions, and more resilient data products. With ChatGPT-5.5 as your co-pilot, you can spend less time wrestling with boilerplate and more time delivering impactful, trustworthy analysis.