Best AI Prompts for Data Science (2025)

I have a pandas DataFrame with the following schema:

[Paste the output of df.dtypes and df.head(3) here]

Task: [describe exactly what you want to calculate or transform]

Requirements:
- Use only pandas and numpy (no additional libraries)
- Return a function called `transform(df)` that takes the DataFrame and returns [describe expected output]
- Add a docstring with parameter types and return type
- Handle NaN values explicitly

Do not include example usage — just the function.

My pandas pipeline is throwing this error:

```
[paste the full traceback here]
```

Pipeline code:
```python
[paste your code here]
```

DataFrame info at the point of failure:
[paste df.info() and df.head(3) output]

Identify the root cause and provide the corrected code. Explain why the error occurs in one sentence.

Optimize this pandas code for performance. It currently processes [N] rows in [X] seconds.

```python
[paste your slow code here]
```

Schema: [describe relevant columns and types]

Rewrite using vectorized operations. If the operation cannot be vectorized, explain why and suggest the next best approach (e.g., Cython, Dask, chunked processing). Show the before/after with estimated speedup.

Generate a data quality audit script for a pandas DataFrame with this schema:

```
[paste df.dtypes output]
```

Business context: [e.g., "customer transaction data, one row per purchase"]

The script should check for and report:
1. Missing values (count + %) per column
2. Duplicate rows (exact and near-duplicate by key columns)
3. Outliers in numeric columns (IQR method)
4. Date range validity for timestamp columns
5. Cardinality issues (columns that should be categorical but have high cardinality)
6. Foreign key integrity for ID columns [list expected key relationships if any]

Output a single Python function `audit(df)` that returns a dict of findings.

I am doing EDA on a dataset with these columns:
- Target variable: [name, type, e.g. "churn: boolean"]
- Key features: [list 3-5 columns with types]
- Row count: [N rows]
- Domain: [e.g. "e-commerce transactions"]

For each of the following pairs, write seaborn/matplotlib code for the single most informative plot:
1. [feature_1] vs [target]
2. [feature_2] vs [feature_3]
3. [feature_4] distribution overall

Each code block should be standalone and include `plt.tight_layout()` and `plt.title()`. No prose — just code blocks.

Here are summary statistics for my dataset:

```
[paste df.describe() and df.value_counts() output for key columns]
```

Business context: [1-2 sentences on what this data is and the main question you are trying to answer]

Generate 5 data-driven hypotheses worth testing, ranked by likely business impact. For each hypothesis:
- State it as a falsifiable claim
- Identify the columns and statistical test to use
- Estimate the sample size needed for 80% power at α=0.05
- Flag any data quality issues that could invalidate the test

I trained a [model type, e.g. "XGBoost classifier"] for [task, e.g. "predicting 30-day churn"].

Results on the held-out test set:
```
[paste classification_report(), confusion_matrix(), and AUC score]
```

Dataset characteristics:
- Train size: [N], Test size: [M]
- Class distribution: [e.g. "89% negative, 11% positive"]
- Feature count: [N features]

Answer:
1. Is this performance good for this type of problem? Give a benchmark.
2. What is the model's most likely failure mode given these metrics?
3. List the top 3 concrete improvements to try, ordered by expected impact.
4. Is there evidence of data leakage? What would I check?

I am building a model to predict [target variable] using data from [domain].

Raw features available:
[list your current columns with brief descriptions]

Generate 10 engineered features that could improve model performance. For each:
- Feature name (snake_case)
- Computation (pandas code or formula)
- Hypothesis for why it would be predictive
- Whether it requires target encoding, one-hot encoding, or can be used as-is

Prioritize features that capture [recency/frequency/interaction/seasonality — pick what's relevant] effects.

Build a scikit-learn Pipeline for this task:

Goal: [e.g. "binary classification on tabular data"]

Features:
- Numeric columns: [list them] — strategy: [e.g. "StandardScaler + median imputation"]
- Categorical columns (low cardinality): [list them] — strategy: OneHotEncoder
- Categorical columns (high cardinality): [list them] — strategy: [e.g. "OrdinalEncoder or target encoding"]
- Date columns: [list them] — extract: [e.g. "day_of_week, month, days_since_event"]

Model: [e.g. "start with LogisticRegression as baseline, then try LightGBM"]

Include:
- ColumnTransformer for preprocessing
- Cross-validation with StratifiedKFold(5)
- GridSearchCV or RandomizedSearchCV for the top 3 hyperparameters
- Joblib serialization at the end

Return the full pipeline code as a single Python file.

Optimize this SQL query. It currently takes [X seconds] on a table with [N rows].

```sql
[paste your query]
```

Table schemas:
```sql
[paste CREATE TABLE statements or describe column names + types + approximate cardinality]
```

Existing indexes: [list them or say "none"]

EXPLAIN output (if available):
```
[paste EXPLAIN or EXPLAIN ANALYZE output]
```

Return: (1) The optimized query, (2) What changed and why, (3) What index(es) to add if any.

Write a SQL query for cohort retention analysis.

Table: `[table name]`
Columns:
- User ID: `[column name]` (type: [int/varchar])
- Event timestamp: `[column name]` (type: [timestamp/date])
- Event type: `[column name]` — filter to: [e.g. "'purchase'"]

Database dialect: [PostgreSQL / BigQuery / MySQL / Snowflake]

Cohort definition: users grouped by their [week/month] of first [event type]
Retention definition: a user is "retained" in week N if they performed the event at least once in that week

Output: a cohort × week matrix with absolute user counts and retention percentage.
Include comments explaining each CTE.