AI Prompts for Python Coding: 25+ Tested Automation Playbooks (2026)

System Directive:
You are a Principal Python Software Architect and Automation Engineer. I need to design a production-grade Python automation script or data pipeline from complete scratch.

Execution Protocol:
1. Do not generate code immediately.
2. Conduct an interactive discovery consultation with me by asking exactly ONE question at a time. Wait for my answer before proceeding to the subsequent question.
3. Diagnostic Interview Sequence:
   - Question 1: What is the primary operational objective of this Python script, what input data does it ingest (e.g., CSV, JSON, REST API, raw web HTML, SQL database), and what is the target output?
   - Question 2: What Python runtime version are you targeting (e.g., Python 3.11, 3.12, 3.13), and what specific dependency management tool are you using (Poetry, uv, pip, Conda)?
   - Question 3: Are there strict library constraints (e.g., standard library only, Pandas vs. Polars, Playwright vs. BeautifulSoup)?
   - Question 4: What is the expected data volume, execution frequency, and failure tolerance (e.g., 5,000 rows/sec, scheduled cron job, graceful retry on network timeouts)?
   - Question 5: What deployment environment will run this script (local macOS/Linux, AWS Lambda, Docker container, GitHub Actions)?
4. After I finish answering Question 5, synthesize my inputs into a modular, production-ready Python script architecture complete with type hints, structured logging, and automated error handling.

Act as a Principal Python Tooling Specialist.

Project Parameters:
- Project Name: [INSERT PROJECT NAME]
- Core Objective: [e.g., Automated Web Scraper & Data Pipeline]
- Python Version: Python 3.12+
- Dependency Manager: Poetry / uv

Generate a Complete Project Scaffold:
1. Directory Structure: Clean tree layout separating `src/`, `tests/`, `config/`, and `data/`.
2. `pyproject.toml` Configuration: Include exact dependencies (e.g., Pydantic v2, HTTPX, Loguru, Rich, Pytest).
3. Code Quality Configuration: Settings for Ruff (linter/formatter) and Mypy (strict static type checking).
4. `config.py` Settings Module: Pydantic `BaseSettings` class loading environment variables with strict type validation.
5. Entrypoint Script (`main.py`): Minimal runnable entrypoint with clean CLI argument parsing using `argparse` or `typer`.

Act as a Python Performance Optimization Specialist.

Legacy / Inefficient Python Code:
```python
[PASTE SLOW OR UNTYPED PYTHON CODE HERE]
```

Refactoring Directives:
1. Modern Idiomatic Syntax: Upgrade to Python 3.12+ syntax (structural pattern matching `match/case`, f-string enhancements, pipe union operator `|`).
2. Type Annotation: Add strict type annotations across all function arguments and returns using `typing` primitives.
3. Performance Optimization: Replace slow iterative `for` loops with vectorized operations, list/dict comprehensions, or memory-efficient generator expressions.
4. Profiling Explanation: Provide Big-O time and space complexity comparison between original and refactored versions.

Act as a Web Scraping & Data Extraction Specialist.

Scraping Target:
- Target Site / Data: [DESCRIBE TARGET URL & DATA TO EXTRACT]
- Expected Volume: [e.g., 500 Pages]
- Constraints: Must not overload target server; must handle rate limits gracefully.

Generate a Production-Grade Python Scraper:
1. Async Client Architecture: Use `httpx.AsyncClient` with `asyncio.gather` bounded by an `asyncio.Semaphore(10)` to cap concurrent connections.
2. Resilience & Retries: Integrate `tenacity` for exponential backoff retries on `429 Too Many Requests` and `5xx` server errors.
3. User-Agent & Header Rotation: Rotate realistic browser request headers.
4. HTML Parsing: Parse target DOM nodes cleanly with BeautifulSoup4 using CSS selectors.
5. Data Export: Stream extracted records directly into a clean CSV or JSON Lines (`.jsonl`) file.

Act as a Headless Browser Automation Engineer.

Target Web Application:
- Target URL: [INSERT URL]
- Dynamic Behavior: [e.g., Infinite scroll, client-side React rendering, data loaded via lazy API calls]
- Target Fields: [LIST REQUIRED DATA FIELDS]

Build a Playwright for Python Script:
1. Async Playwright Setup: Launch headless Chromium with stealth flags and realistic viewport dimensions.
2. Dynamic Interaction: Scroll the DOM progressively until all lazy-loaded elements render.
3. Network Interception: Intercept background JSON API responses directly via `page.on("response", ...)` to extract raw data without parsing fragile DOM elements.
4. Wait States: Use explicit `wait_for_selector` or network idle states rather than fragile `time.sleep()`.
5. Provide the executable async script with error handling.

You are a Backend API Integration Engineer.

API Details:
- API Base URL & Resource: [e.g., https://api.example.com/v1/customers]
- Authentication: Bearer JWT Token via Environment Variable `API_KEY`
- Pagination Style: Cursor-based pagination (`cursor` query param returning `next_cursor`)
- Rate Limit: 10 requests per second

Build a Robust Python API Client:
1. Typed Client Class: Create a reusable `APIClient` class using `httpx`.
2. Automated Pagination Loop: A generator function `fetch_all_records()` that automatically traverses cursor pages until exhaustion.
3. Rate Limit Enforcement: Implement a token-bucket or sleep throttle ensuring the client never exceeds 10 requests/sec.
4. Structured Logging: Log batch progress, records fetched, and response status codes using standard Python `logging`.

Act as a Senior Data Engineer specializing in Pandas.

Raw Dataset Profile:
- File Format: Raw CSV / Excel file with 50,000 messy rows.
- Data Issues: Inconsistent date formats (MM/DD/YYYY vs. YYYY-MM-DD), mixed string casing, null values, currency symbols in numeric columns, duplicate transaction IDs.

Build an End-to-End Data Cleaning Script:
1. Memory-Optimized Ingestion: Read CSV specifying explicit `dtypes` to minimize memory footprint.
2. String Sanitization: Strip whitespace, lowercase, and remove special characters from text columns.
3. Numeric & Currency Coercion: Use regex to remove `$`, commas, and convert dirty strings into clean `float64` or `int64`.
4. Datetime Normalization: Parse mixed dates into standardized ISO UTC timestamps using `pd.to_datetime`.
5. Missing Value & Deduplication Strategy: Drop exact duplicates, impute missing numerical values with median, and flag missing categories.
6. Export: Save the sanitized dataset to both CSV and compressed Parquet format.

Act as a High-Performance Data Systems Specialist.

Data Processing Task:
- Input Data: 10 Million row Parquet file `transactions.parquet`
- Objective: Group by `customer_id` and `category`, calculate total spend, 90-day rolling average, and filter for high-value outliers.

Write a Polars Data Pipeline:
1. Lazy Evaluation: Use `pl.scan_parquet()` to construct a lazy query plan that utilizes predicate pushdown and parallel thread execution.
2. Window Functions & Aggregation: Calculate total revenue, transaction count, and percentile rank within each group.
3. Expression Syntax: Write idiomatic Polars expressions avoiding slow Python `apply()` or lambda loops.
4. Output Streaming: Collect and stream results directly into an optimized output file without memory exhaustion.

Act as a Regular Expressions (Regex) and Text Processing Specialist.

Raw Text Sample:
```
[PASTE 3-5 ROWS OF UNSTRUCTURED SERVER LOGS, TRANSACTION EMAILS, OR INVOICE TEXT]
```

Target Values to Extract:

Act as a Principal Python QA Automation Engineer (SDET).

Target Python Code to Test:
```python
[PASTE PYTHON FUNCTION, CLASS, OR API SERVICE HERE]
```

Build a Comprehensive Pytest Suite:
1. Pytest Fixtures: Create reusable fixtures (`@pytest.fixture`) for sample input data, database connections, and authenticated client sessions.
2. Parameterized Tests: Use `@pytest.mark.parametrize` to test 5 distinct boundary inputs (empty lists, negative numbers, extreme floats, null values).
3. Mocking External I/O: Use `unittest.mock.patch` to mock all external network requests, database transactions, and filesystem reads.
4. Exception Assertions: Test that invalid arguments trigger expected custom exceptions using `with pytest.raises(...)`.
5. Code Formatting: Organize tests cleanly into `TestClassName` suites with descriptive test function names.

You are a Formal Software Verification Engineer.

Target Python Function:
```python
[PASTE CORE LOGIC OR DATA SERIALIZATION FUNCTION HERE]
```

Generate a Property-Based Test Suite using Hypothesis:
1. Invariant Identification: Define 3 mathematical or logical properties that must always hold true (e.g., round-trip serialization `loads(dumps(x)) == x`, idempotency, monotonic growth).
2. Data Strategies: Define custom Hypothesis data strategies generating complex strings, floats, nested dictionaries, and boundary integers.
3. Fuzzing Test Suite: Write executable test functions decorated with `@given(...)` that run 1,000 automated iterations to test for unhandled exceptions or overflow crashes.

Act as a DevSecOps Engineer and Python CI/CD Specialist.

Project Requirements:
- Python Versions: Test across Python 3.11, 3.12, and 3.13.
- Tools: Ruff (formatting & linting), Mypy (type checking), Pytest (unit testing with coverage).

Generate a Complete GitHub Actions Workflow:
1. Fast Dependency Caching: Cache virtual environments and package wheels to achieve sub-60-second build times.
2. Matrix Strategy: Run tests in parallel across all specified Python versions.
3. Multi-Step Quality Gates:
   - Step 1: `ruff check` and `ruff format --check`.
   - Step 2: `mypy --strict src/`.
   - Step 3: `pytest --cov=src --cov-report=xml`.
4. Failure Reporting: Configure clear terminal error output on failed lint or test steps.

Act as a Systems Automation and Python Scripting Specialist.

Task Specifications:
- Source Directory: `/path/to/messy_downloads`
- Rules:
  - Organize files into subdirectories based on creation year and month (`YYYY/MM/`).
  - Convert all `.png` and `.jpg` images to optimized `.webp` at 90% quality using Pillow, preserving original aspect ratios.
  - Delete empty directories and log all moved files to a CSV audit log.

Build a Robust Python Automation Script:
1. Pathlib Architecture: Use `pathlib.Path` for modern, cross-platform file manipulation (Windows/macOS/Linux compatible).
2. Image Processing: Safely process images with `PIL.Image`, handling transparency channels and EXIF orientation metadata.
3. Safety Check / Dry Run: Include a `--dry-run` flag so users can preview file moves before committing disk writes.
4. Error Handling: Gracefully skip locked or corrupt files without crashing the script.

Act as a Document Ingestion and PDF Parsing Specialist.

Document Parameters:
- Input File: Multi-page PDF invoices or bank statements.
- Extraction Goals: Extract invoice number, date, vendor name, line-item table, and total amount.

Build a Python PDF Extraction Script:
1. Library Selection: Use `pdfplumber` for table extraction and `pypdf` for metadata and form fields.
2. Table Reconstruction: Extract multi-column tables, clean header rows, and handle multi-line wrapped text inside cells.
3. Text Fallback: If tables fail to extract, use regex fallback patterns across the raw extracted text.
4. Export Pipeline: Save extracted data into clean JSON format and export summary tables to Excel using `openpyxl`.

Act as a Python CLI Developer and Developer Experience (DX) Engineer.

CLI Tool Concept:
- Tool Name: [INSERT CLI NAME, e.g., `audit-tool`]
- Commands:
  - `audit-tool run --url <url> --depth <int>`
  - `audit-tool report --format <json|table>`
  - `audit-tool config set --key <key> --val <val>`

Build a Beautiful Terminal CLI with Typer & Rich:
1. Typer Command Architecture: Define type-annotated CLI subcommands with auto-generated `--help` flags.
2. Rich Terminal Formatting:
   - Colored status panels and banners.
   - Interactive live progress bars (`rich.progress.Progress`).
   - High-contrast ASCII tables displaying scan results.
3. Exit Codes: Enforce standard Unix exit codes (`0` for success, `1` for error) for shell script integration.