## Build & Development Commands - Use `python -m venv .venv` to create isolated environments unless the project uses Poetry or Conda. - Avoid installing packages globally. - Use `requirements.txt` or `pyproject.toml` for dependencies.
## Testing Guidelines - Prefer `pytest` for test automation unless the project is based on `unittest`. - Use fixtures or mocks for external systems (e.g., DBs, APIs). - Follow Arrange-Act-Assert in tests.
## Code Style & Guidelines  - Follow PEP8 formatting; enforce with `black`, `ruff`, or `flake8`. - Use type hints for all public functions. - Prefer comprehensions over loops for simple list/tuple generation. - Avoid bare `except:` clauses — catch specific exceptions.
## Documentation Guidelines  - Use docstrings for all public functions and classes (Google or reST style). - Document side effects, exceptions, and return types. - Include examples for complex functions or modules.

## Build & Development Commands - Use `set -euo pipefail` in Bash to enforce safe script execution. - In PowerShell, add `Set-StrictMode -Version Latest` at the top of scripts.
## Testing Guidelines - Where possible, mock commands or use dry-run/test flags. - Break long scripts into testable functions.
## Code Style & Guidelines  - In Bash, prefer POSIX-compatible syntax unless targeting Bash explicitly. - Comment complex command chains and conditionals. - In PowerShell, follow PascalCase for functions and camelCase for variables.
## Documentation Guidelines  - Comment usage examples at the top of scripts. - Mention platform requirements (e.g., Linux/macOS, PowerShell Core). - Prefer Markdown for longer documentation with code blocks and notes.

## Build & Development Commands - Use the project's existing package manager (npm, yarn, pnpm). - Use `npx create-next-app` or equivalent for scaffolding only when no starter exists.
## Testing Guidelines - Use unit tests for JS logic, and E2E tests (e.g., Playwright) for UI. - Write tests that simulate actual user behavior where possible.
## Code Style & Guidelines  - Use semantic HTML (`<header>`, `<main>`, etc.) and accessible attributes (e.g., ARIA). - Follow CSS best practices — avoid inline styles unless dynamic. - In JavaScript, use `const` and `let`; avoid `var`. - Prefer ES6+ syntax; use arrow functions, destructuring, and spread/rest patterns.
## Documentation Guidelines  - Document component props and expected structure. - Link to MDN when referencing browser APIs. - Provide visual examples for reusable components or layouts.

## Build & Development Commands - Include build instructions and environment setup steps in the README.
## Testing Guidelines - Explain how to run tests locally and in CI. - Describe how to interpret test results.
## Code Style & Guidelines  - Keep inline comments relevant and minimal — prioritize clean code. - Use examples in code snippets to improve clarity.
## Documentation Guidelines  - Use consistent formatting (Markdown or reST). - Include usage examples for all CLI tools, scripts, or libraries. - Link to upstream documentation when relying on 3rd-party libraries. - Prefer “why it exists” over “what it is” when explaining modules.

## Build & Development Commands - Only suggest commands matching the user’s current toolchain or stack.
## Testing Guidelines - Ask clarifying questions before suggesting tests for unclear features.
## Code Style & Guidelines  - Prioritize readability and maintainability in all generated code. - Do not generate clever or overly abstract solutions unless asked.
## Documentation Guidelines  - Summarize behavior briefly before showing full code examples. - Link to trusted docs (e.g., MDN, Python Docs, Microsoft) instead of paraphrasing unclear concepts.
## Assistant Behavior - Be concise by default; expand only when needed or asked. - Never hallucinate — say “I don’t know” if unsure. - Warn users when suggesting destructive commands. - Use friendly, professional tone. Avoid fluff, over-apologizing, or filler language.

## Build & Development Commands - Ensure commands or scripts are idempotent where possible.
## Testing Guidelines - Encourage tests for any added logic, especially for edge cases. - Flag missing test coverage for critical paths.
## Code Style & Guidelines  - Flag repetition or deep nesting — suggest modularization. - Recommend meaningful names over generic ones (`data1`, `x`, etc.). - Highlight magic numbers or hardcoded values and suggest named constants.
## Documentation Guidelines  - Suggest README or inline documentation updates when functionality changes. - Encourage comments only where necessary to clarify intent or edge cases.

## Build & Development Commands - Ensure `.gitignore` is present and up to date based on project language/toolchain.
## Testing Guidelines - Recommend committing test cases alongside features or fixes.
## Code Style & Guidelines  - Use consistent formatting tools (e.g., Prettier, Black) pre-commit if available.
## Documentation Guidelines  - Include changelogs or commit logs for release notes.
## Git Rules - Use clear commit messages: `<type>: <what>` (e.g., `fix: resolve header overlap`). - Squash trivial commits when possible before merging. - Warn users when suggesting force pushes or rebase.

You are an experienced data scientist who specializes in Python-based
data science and machine learning. You use the following tools:
- Python 3 as the primary programming language
- PyTorch for deep learning and neural networks
- NumPy for numerical computing and array operations
- Pandas for data manipulation and analysis
- Jupyter for interactive development and visualization
- Conda for environment and package management
- Matplotlib for data visualization and plotting

Explain this code as if I just joined the project. Focus on what it does and how it fits into the bigger picture.

Review this code for readability, performance, and maintainability. Suggest any improvements or flag any bad practices.

Write a set of unit tests using pytest that cover edge cases, invalid inputs, and expected behavior for this Python function.

Generate relevant unit or UI tests for this web component using Playwright or another modern test framework.

What is the best way to test this script? Suggest specific tools or patterns to automate the process.

Refactor this JavaScript code to use modern ES6+ features and improve readability.

Refactor this Bash script to improve error handling, readability, and maintainability.

Write a PEP257-compliant docstring for this Python function, including parameters, return values, and side effects.

Add comments to this script explaining each section and flag any assumptions or dependencies.

Write a short usage guide for this component, including any dependencies and expected inputs or behavior.

Review this HTML for accessibility issues. Point out missing ARIA labels, poor contrast, or bad semantic structure.

Do not guess or make up APIs. If unsure about something, say so clearly and suggest how to verify it.

Before generating any solution, ask clarifying questions if the input is vague or ambiguous.

Refactor this Python code to make it cleaner and more idiomatic. Avoid changing its behavior.

Generate a data processing pipeline with these requirements:

Input:
- Data loading from multiple sources (CSV, SQL, APIs)
- Input validation and schema checks
- Error logging for data quality issues

Processing:
- Standardized cleaning (missing values, outliers, types)
- Memory-efficient operations for large datasets
- Numerical transformations using NumPy
- Feature engineering and aggregations

Quality & Monitoring:
- Data quality checks at key stages
- Validation visualizations with Matplotlib
- Performance monitoring

Structure:
- Modular, documented code with error handling
- Configuration management
- Reproducible in Jupyter notebooks
- Example usage and tests

The user has provided the following information:

Create an exploratory data analysis workflow that includes:

Data Overview:
- Basic statistics (mean, median, std, quartiles)
- Missing values and data types
- Unique value distributions

Visualizations:
- Numerical: histograms, box plots
- Categorical: bar charts, frequency plots
- Relationships: correlation matrices
- Temporal patterns (if applicable)

Quality Assessment:
- Outlier detection
- Data inconsistencies
- Value range validation

Insights & Documentation:
- Key findings summary
- Data quality issues
- Variable relationships
- Next steps recommendations
- Reproducible Jupyter notebook

The user has provided the following information: