18 ready-to-use ChatGPT prompts for data science and machine learning. Fill in the bracketed fields, paste into ChatGPT, and go.
Engineering · 18 prompts
01
Build a Pandas Data Cleaning Pipeline with Rules, Logging, and Output Guarantees
Generate a pandas cleaning pipeline that handles duplicates, missing values, type normalization, and reproducible output checks instead of a one-off notebook-style script.
You are a senior data scientist.
Produce code or a code scaffold for a pandas data cleaning pipeline.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: missing values imputed with a single blanket strategy such as always mean-filling without checking whether the column is actually numeric-continuous or categorical, duplicate detection based on exact row match that misses near-duplicates from formatting differences, type coercion applied silently so a column that should error on bad data instead gets NaNs with no report of how many rows were affected, and no before/after row-count or distribution check to confirm the cleaning didn't quietly destroy more data than intended.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including before/after distribution checks)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
02
Build a Customer Churn Classification Workflow with Evaluation and Retention Context
Create a practical churn-model workflow with scikit-learn that covers target definition, leakage risks, evaluation tradeoffs, and how outputs connect to retention decisions.
You are a senior data scientist advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: a target definition of what counts as 'churned' left ambiguous, producing a model trained on an inconsistent label, features that use information only available after the churn event already leaking into training, evaluation focused on accuracy instead of the actual retention-team cost of a missed churner versus a false alarm, and no plan for how model output actually gets used operationally, meaning who acts on a churn score and when.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Target definition and label consistency
- Leakage check on feature timing
- Evaluation tied to retention-team cost tradeoffs
- Operational use of the model's output
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
03
Optimize a Model with Grid Search
Diagnose weak model performance and tune hyperparameters with a disciplined grid search approach.
You are a senior data scientist debugging assistant working on a real model-performance issue.
Diagnose and improve the technical issue below.
Context:
- Problem description: [problem]
- Stack or environment: [stack]
- Current system role or production impact: [system role]
- Expected behavior: [expected]
- Actual behavior: [actual]
- Relevant code, logs, traces, metrics, or signals: [evidence]
Instructions:
1. Check first for the causes that actually produce this class of problem: a search space defined without checking whether the model is even underfitting or overfitting first, tuning that optimizes against the same data used for training without a separate validation fold, a huge Cartesian grid searched exhaustively when a randomized or Bayesian search would find nearly as good a result at a fraction of the cost, and the 'best' parameters selected treated as final with no sanity check on a genuinely held-out test set.
2. Explain the debugging path in priority order based on risk, probability, and speed of confirmation.
3. Recommend fixes, mitigations, or containment steps and when each is appropriate.
4. Include how to validate the fix and what to monitor after rollout.
5. Keep the answer concise, operational, and biased toward restoring reliability.
Output format:
- Likely root causes (checked against the failure modes above)
- Highest-priority diagnostic steps
- Fix or containment options
- Validation and post-fix monitoring
- Main assumptions or risks
Missing information policy:
Ask up to 2 concise questions only if the stack, production impact, or failure mode is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prioritize root cause over guesswork.
- Name the specific failure modes above rather than generic debugging advice.
- Explain how to verify the fix.
- Include the operational reality of shipping the change safely.
04
Design Feature Engineering for a Regression Model with Leakage, Drift, and Interpretability Controls
Design feature engineering for a regression model with leakage control, transform choices, drift awareness, and interpretability tradeoffs tied to the decision context.
You are a senior data scientist advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: transformed features computed using statistics like mean or min/max from the full dataset instead of fit only on training data, leaking test-set information, feature interactions added without checking if they actually improve holdout performance versus just adding noise, no monitoring plan for feature drift once the model is in production, and interpretability sacrificed for marginal performance gains without checking whether stakeholders actually need to explain individual predictions.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Feature transformation fit only on training data
- Interaction terms validated against holdout performance
- Feature-drift monitoring plan
- Interpretability tradeoff decision
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
05
Build a Decision Tree Training and Visualization Script with Interpretability Notes
Generate Python code that trains a decision tree, controls overfitting, and produces a readable visualization with the key interpretability choices explained.
You are a senior data scientist.
Produce code or a code scaffold for a decision tree training and visualization script.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: a tree grown to full depth with no pruning or max-depth constraint, producing a visualization that's technically accurate but useless for interpretation because it's too large, feature importance read directly off the tree structure without accounting for high-cardinality features that trees are biased toward splitting on, no comparison against a simple baseline like a shallow tree or logistic regression to check if the complexity is earning its keep, and the visualization built on training data performance with no indication of how well the tree generalizes.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including generalization check)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
06
Design and Validate a TensorFlow Image Classification Training Workflow
Design and validate a TensorFlow image classification workflow with dataset preparation, model choice, evaluation discipline, and deployment-relevant failure checks.
You’ll needdataset typeclass structuredata volume and qualityevaluation goaldeployment or inference contextconstraints
Prompt
You are a senior data scientist advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: training data assumptions like class balance and image quality never explicitly checked before training starts, data augmentation applied in a way that doesn't reflect realistic variation the model will see in production, a validation set drawn from the same source or distribution as training in a way that hides real-world generalization gaps, and deployment considerations like inference latency or model size never factored into the architecture choice.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Dataset assumptions and checks before training
- Augmentation matched to realistic production variation
- Validation-set representativeness check
- Deployment-oriented architecture decisions
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
07
Build a K-Means Segmentation Workflow with Cluster Validation and Actionability Checks
Generate a Python workflow for k-means segmentation that handles scaling, cluster-count validation, visualization, and checks whether the resulting segments are usable for real decisions.
You’ll needdataset contextfeature setcluster count approachbusiness use casevisualization needsconstraints
Prompt
You are a senior data scientist.
Produce code or a code scaffold for a k-means segmentation workflow.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: features left unscaled before clustering so a high-magnitude column dominates the distance metric, cluster count chosen without validating it against a method like silhouette score, visualization done in raw feature space instead of a reduced projection that misrepresents cluster separation, and no check for whether the resulting clusters are actually stable across repeated runs with different random seeds.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including cluster-stability checks)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
08
Plan ML Model Deployment with Flask and Docker
Create a plan for deploying a machine learning model using Flask and Docker.
You are a senior data science and machine learning architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: the model wrapped in a Flask endpoint with no input validation, so malformed requests crash the service instead of returning a clear error, no versioning strategy for the model artifact, making it unclear which model version is actually serving predictions, a container built without pinning dependency versions so a rebuild months later silently changes behavior, and no monitoring for prediction drift or latency once the model is live.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
09
Evaluate Classification Performance with Threshold, Cost, and Error Tradeoffs
Evaluate classification performance with threshold, class-balance, and business-cost tradeoffs instead of reporting precision, recall, and F1 in isolation.
You are a senior data scientist advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: precision, recall, and F1 reported without tying the classification threshold to the actual cost of a false positive versus false negative, macro versus weighted averaging chosen without understanding which one hides minority-class performance, a single aggregate score used to declare success without a per-class breakdown, and metrics validated on a test set whose class balance doesn't match production.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Threshold choice tied to business cost
- Averaging method justified (macro vs weighted)
- Per-class performance breakdown
- Test-set class balance matched to production
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
10
Build a PCA Workflow with Scaling, Component Selection, and Interpretation Notes
Generate a PCA workflow that covers scaling, component selection, explained-variance review, and interpretation limits instead of treating PCA as a blind preprocessing step.
You’ll needdataset shapefeature countscaling approachdownstream use caseinterpretability needsconstraints
Prompt
You are a senior data scientist.
Produce code or a code scaffold for a PCA dimensionality reduction workflow.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: PCA applied without scaling first, letting high-variance features dominate the components regardless of their actual importance, the number of components chosen arbitrarily instead of based on explained-variance analysis, components treated as if they retain interpretable meaning from the original features without checking the loadings, and PCA applied to the full dataset before a train/test split, leaking test-set variance structure into training.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including explained-variance justification)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
11
Use Cross-Validation to Assess ML Performance
Develop a guide for using cross-validation techniques to assess model performance.
You are a senior data scientist advising on a real model-evaluation setup rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Recommend a cross-validation scheme (k-fold, stratified, group, or time-series split) suited to the data and evaluation goal, and justify why.
2. Tailor the guidance to the stated dataset size, class balance, and constraints.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually invalidate cross-validation: data leakage across folds when rows share a group, subject, or time window; using plain k-fold on imbalanced classes instead of stratified splits; treating a single fold's metric as ground truth instead of reporting variance across folds; and choosing k high enough to be computationally wasteful without improving estimate reliability.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Recommended cross-validation scheme and fold strategy
- Leakage and stratification checks specific to this dataset
- Metric reporting approach (mean, variance, confidence interval across folds)
- Compute-cost tradeoff for the chosen k or repeat count
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the dataset structure, evaluation goal, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific leakage and reporting failure modes above rather than generic "use cross-validation" advice.
- Make the advice usable by a team validating a real model.
12
Create a Collaborative Filtering Recommender
Create a recommendation system using collaborative filtering with the Surprise library.
You are a senior data scientist.
Produce code or a code scaffold for a collaborative filtering recommendation system.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: the interaction matrix built with no handling for the cold-start case of a new user or item with no history, evaluation done with a single accuracy-style metric that doesn't reflect ranking quality, matrix factorization or similarity computation performed without checking for data sparsity that makes the model unreliable, and no plan for how recommendations degrade gracefully rather than returning nothing when the model has low confidence.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including cold-start and sparsity checks)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
13
Build a Random Forest Classification Workflow with Evaluation and Feature Review
Generate Python code for a random forest classification workflow that includes training, evaluation, and a practical review of feature importance and model behavior.
You are a senior data scientist.
Produce code or a code scaffold for a random forest classification workflow.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: feature importance interpreted directly from the model without accounting for correlated features that split importance artificially across them, class imbalance in the training data left unaddressed so the model looks accurate while ignoring the minority class, no out-of-bag or cross-validation estimate reported, relying only on training accuracy, and hyperparameters like tree depth and count left at library defaults with no tuning pass justified by the actual dataset size.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including out-of-bag/cross-validation estimate)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
14
Design a Strategy for an Imbalanced Dataset with Sampling and Metric Tradeoffs
Provide a strategy for handling class imbalance that weighs resampling, thresholding, class weighting, and metric selection against the real decision context.
You’ll needdataset contextimbalance severitymodel typeevaluation goalbusiness cost of errors
Prompt
You are a senior data science and machine learning architect creating a plan for a real engineering initiative.
Create a plan for the task below.
Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]
Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: resampling applied before the train/test split instead of only within the training fold, leaking synthetic or duplicated information into evaluation, a single technique like oversampling chosen without comparing it against class weighting or threshold adjustment, evaluation reported on accuracy despite the imbalance making that number meaningless, and no connection made between the chosen strategy and the actual business cost of the two error types.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.
Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions
Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.
Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
15
Build an ARIMA Forecasting Workflow with Diagnostics and Forecast Boundaries
Write a practical ARIMA forecasting guide that covers stationarity checks, order selection, residual diagnostics, and when ARIMA is the wrong tool.
You’ll needtime series contextforecast horizonstationarity issuesseasonality patterndecision use caseconstraints
Prompt
You are a senior data scientist advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: stationarity assumed rather than tested before fitting, order selection done by trial and error with no diagnostic justification, seasonality present in the data but not explicitly modeled or differenced out, and residual autocorrelation never checked, so a systematically biased forecast looks fine until it's deployed.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Stationarity testing before model fitting
- Order selection with diagnostic justification
- Seasonality modeling decision
- Residual diagnostics and forecast boundaries
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
16
Interpret a Machine Learning Model with SHAP or LIME for Stakeholder Review
Interpret a machine learning model with SHAP or LIME in a way that surfaces feature impact, explanation limits, and stakeholder-safe conclusions.
You’ll needmodel typestakeholder audienceexplanation goaldecision contextknown model caveatsconstraints
Prompt
You are a senior data scientist advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: SHAP or LIME explanations generated without checking whether the underlying model is well-calibrated, making the explanation of an unreliable prediction misleadingly convincing, correlated features distorting attributed importance in ways that aren't disclosed to stakeholders, explanations presented as global truth when they're locally valid for one prediction and can look completely different for another, and no plain-language translation layer between the technical output and what a non-technical stakeholder actually needs to decide.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Model calibration check before explaining
- Correlated-feature distortion disclosure
- Local vs global explanation scope clarified
- Stakeholder-safe translation of findings
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
17
Build a Social Sentiment Collection and Analysis Script with Source and Quality Limits
Create a Python workflow for collecting and analyzing social sentiment while accounting for source limitations, text cleanup, and the weak reliability of naive sentiment scoring.
You are a senior data scientist.
Produce code or a code scaffold for a social sentiment collection and analysis workflow.
Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]
Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: sentiment scored with a generic pretrained lexicon that doesn't account for domain-specific language such as sarcasm or slang common in social text, a sample collected from a platform or search term that isn't actually representative of the broader population being studied, no deduplication of retweets or reposts that can make a single viral post look like widespread sentiment, and results reported as a single aggregate score with no confidence interval or sample-size context.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.
Output format:
- Implementation approach
- Code
- Validation and test cases (including representativeness and dedup checks)
- Integration notes and assumptions
Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.
Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
18
Design a Transfer Learning Fine-Tuning Strategy with Compute, Drift, and Error Review
Design a transfer learning fine-tuning strategy with base-model choice, layer-freezing decisions, compute limits, drift risk, and deployment-relevant error review.
You are a senior data scientist advising on a real implementation rather than teaching a generic tutorial.
Help with the engineering task below.
Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]
Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: the entire pretrained network fine-tuned at once with a learning rate too high, destroying the pretrained features instead of adapting them, layer-freezing decisions made without regard for how similar the new task is to the original pretraining task, a compute budget not checked against the actual fine-tuning schedule needed, causing an under-trained model to be shipped, and no drift-monitoring plan for when the fine-tuned model's performance degrades as the new domain's data shifts over time.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.
Output format:
- Base-model and layer-freezing decisions
- Learning-rate strategy for fine-tuning
- Compute budget vs training schedule check
- Drift-monitoring plan post-deployment
- Main assumptions and risks
Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.
Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.