python-engineering

Analyzes failing test cases to determine whether failures indicate genuine bugs or incorrect test implementations. Use when debugging test failures, investigating test errors, classifying failures as test bugs vs implementation bugs vs ambiguous behavior, or when given specific failing test names or pytest output. Applies balanced investigative reasoning — never auto-fixes tests without establishing root cause first.

Use when writing asyncio Python code — async/await coroutines, concurrent I/O with asyncio.gather, task creation and cancellation, semaphore rate limiting, producer-consumer queues, async context managers, async generators, WebSocket servers, aiohttp web scraping, async database operations, run_in_executor for blocking calls, or testing async code with pytest-asyncio. Covers FastAPI and aiohttp patterns, synchronization primitives, timeout handling, and common pitfalls like event loop blocking and missing await.

Runs structured Python cleanup and modernization — static analysis via prek/ruff, smell investigation to root cause, typed-boundary hardening by inventorying Any usage, and modernization within the project's requires-python lane. Use when refactoring Python code, removing dead code, hardening type boundaries, or running a modernization pass on a file or scope.

Performs checklist-driven review of pytest test suites against coverage thresholds (80% line/branch minimum, 95% for critical paths), AAA pattern adherence, pytest-mock usage, test isolation, naming clarity, type hints, and flaky pattern detection. Use when auditing test quality before a release, reviewing coverage gaps, checking tests for completeness or best practices, or validating mocking standards. Accepts a test file or directory as input and outputs prioritized findings grouped by HIGH, MEDIUM, and LOW priority.

Use when creating a new feature development task — scaffolds a structured task file at .claude/tasks/{feature-name}.md with phased breakdown (Design, Implementation, Testing, Documentation), acceptance criteria, context preservation, and TaskCreate tracking. Activates on "create a feature task", "set up development tracking", "plan a feature implementation", or when preparing work for python-cli-architect or python-pytest-architect agents.

Structured 6-phase Python debugging workflow covering problem intake, scoping, hypothesis formation, systematic investigation, root-cause analysis, and fix implementation. Use when diagnosing tracebacks, test failures, AttributeError, TypeError, intermittent failures, async/await issues, or any unexpected Python behavior. Applies a dual-hypothesis approach (implementation bug vs test bug), minimal reproduction isolation, data-flow tracing, and produces a structured Bug Investigation Report with confirmed root cause and regression test.

Use before any CLI/TUI display code is written, modified, or audited — runs the 7-stage discipline (Context, Register, Shape brief, Implement, Critique, Audit, Polish) for Typer, Rich, Textual, and Questionary work, grounded in per-project PRODUCT.md and DESIGN.TUI.md/DESIGN.md. Triggers on output formatting, display design, interactive prompts, visual consistency, TUI layout, progress display, dashboard design, design audit, design polish, design critique, shape brief, register decision (brand-cli vs product-cli), and AI-slop checks.

Provides Hatchling build backend guidance for Python packaging — use when configuring pyproject.toml metadata, build targets (wheel, sdist, binary), file selection with git-style globs, build hooks, metadata hooks, version management (code/regex/env sources), editable installs, the hatch-vcs plugin, plugin development, build environment setup (UV/pip/Cython), setuptools migration, or troubleshooting Hatchling errors. Covers PEP 517/518/621/660 standards and context variable interpolation.

Runs deterministic Python quality checks against a path or scope — formatting, linting, type checking, and typing-boundary policy. Use when checking or fixing code quality via prek, ruff, ty, pytest, or the check-typing-boundaries policy script. Reports results grouped by category; fixes only when explicitly requested.

MkDocs documentation project reference covering CLI commands, mkdocs.yml configuration, Material theme setup, and plugin integration. Bundled references include complete CLI parameters, all mkdocs.yml settings with valid values, Material theme customization options, and plugin configs for mkdocstrings, mermaid2, mkdocs-gen-files, mkdocs-literate-nav, and mkdocs-typer2. Use when initializing a MkDocs site, configuring mkdocs.yml, customizing the Material theme, integrating plugins, building static docs from Markdown, or generating API documentation from Python docstrings.

Applies and teaches Python 3.11+ modernization patterns with PEP citations. Use when reviewing or writing Python code to apply built-in generics (PEP 585), pipe unions (PEP 604), walrus operator (PEP 572), match-case (PEP 634), Self type (PEP 673), exception notes (PEP 678), StrEnum, tomllib, pytest-mock fixtures, Typer Annotated syntax, or Rich terminal output — or when refactoring legacy typing imports or elif chains to modern equivalents.

Use when implementing a Python feature, adding CLI commands, writing pytest suites, reviewing Python code, debugging, or refactoring. The primary Python engineering workflow orchestrator — classifies the task and delegates through this plugin's own specialist agents (architect → implement → test → review), sized to the task. Delegates to python-cli-architect (implementation), python-pytest-architect (tests), code-reviewer (review), python-cli-design-spec (architecture). Triggers on any Python task requiring specialist agent coordination or multi-agent execution.

Provides agent selection criteria, workflow patterns (TDD, feature addition, code review, refactoring, debugging), quality gates, and python-cli-architect vs stdlib-scripting routing for Python engineering tasks. Activated by python-engineering:orchestrate at Step 1 before any task is routed. Also activates when an orchestrator needs to select the correct Python specialist agent or chain agents across a multi-step Python workflow.

Configures and runs git hooks with prek (or the pre-commit it replaces — same `.pre-commit-config.yaml`). Use when adding or troubleshooting git hooks, writing a `prepare-commit-msg` or `commit-msg` stage hook, or authoring `.pre-commit-hooks.yaml` for hook distribution.

Generates professional PyPI-compliant README files in Markdown or reStructuredText. Use when creating a Python package README for PyPI publication, converting between README.md and README.rst formats, validating markup with twine check before publishing, configuring the readme field in pyproject.toml, integrating sphinx-readme to generate PyPI-compatible RST from Sphinx docs, troubleshooting rendering errors on PyPI, or previewing README rendering locally with grip or docutils.

Use when writing Python scripts that must run on Windows, Linux, and macOS — especially when Rich or Typer output breaks on Windows, when dealing with Unicode/encoding errors, ANSI escape handling, terminal detection, path separators, or console color support. Provides verified cross-platform patterns covering stdout/stderr encoding guards, Windows console quirks, terminal capability detection, and portable I/O for CLI, TUI (Rich/Textual), and GUI environments.

Executes a four-phase feature addition workflow (Discovery, Planning, TDD Implementation, Verification) for Python projects. Use when adding a new feature end-to-end — discovering project structure and integration points, drafting a feature spec with MoSCoW-prioritized requirements and BDD acceptance criteria, implementing via test-first TDD cycles, then verifying with ruff lint, ty type checks, and 100% coverage on new code.

Use when building CLI applications with Typer and Rich — creating commands with Annotated parameter syntax, defining arguments and options, composing subcommands, async concurrent CLI tasks with semaphores, testing with CliRunner, PEP 723 shebang scripts, progress bars, Rich terminal output, or non-TTY display width handling.

Activates on any Python task involving *.py files, uv, ruff, ty, pytest, or pyproject.toml — loads the shared Python 3.11+ standards and routes the task to the specialist skill that applies them: TDD, CLI, web, data, async, typing, packaging, publishing, documentation sites, test design, test-failure analysis, or stdlib-only constrained environments.

Specialist skill for Python data engineering — pandas, polars, DuckDB, numpy, ETL pipelines, tabular data ingestion, and notebook-to-module extraction. Use when working with dataframes, data validation at ingress boundaries, merge/join operations, typed column contracts, or choosing between pandas vs polars vs DuckDB for a data task.

Configures pyproject.toml and Python packaging using PEP 517/518/621/660/723 standards. Use when creating or updating pyproject.toml, selecting a build backend (hatchling/setuptools/flit), configuring ruff, ty, mypy, pytest, or coverage tool sections, setting up dependency constraints or optional extras, defining CLI entry points, configuring pre-commit hooks, establishing src-layout directory structure, or preparing a package for PyPI publishing.

Configures CI/CD pipelines for automated Python package publishing to PyPI or GitLab Package Registry. Use when creating GitHub Actions or GitLab CI release workflows, setting up trusted publishing or API token-based PyPI authentication, configuring version management with git tags and hatch-vcs, writing pyproject.toml publishing metadata, testing packages against TestPyPI, or documenting the release process for a Python project.

Use when building dependency-free Python 3.11+ scripts for airgapped, stdlib-only, or restricted environments where third-party package installation is prohibited — triggers on "stdlib-only", "airgapped", "no dependencies", "no internet", "restricted environment", or confirmed environments where external packages cannot be installed.

Guides test-driven development for Python using a five-phase red-green-refactor cycle. Use when asked to write tests first, apply TDD, do test-first implementation, or follow red-green-refactor — designs typed interfaces and Protocol classes, writes failing pytest tests (RED), implements minimal passing code (GREEN), verifies with prek or ruff plus pytest-cov, and enforces a quality gate requiring all tests pass with no lint or type errors and coverage at or above 80 percent.

Guides pytest test suite architecture and coverage strategy for Python 3.11+ projects. Activates when designing test architecture, planning test pyramid distribution, choosing between unit/integration/property-based/BDD strategies, structuring fixture hierarchies, configuring branch coverage thresholds, or applying mutation testing to critical code paths.

Pytest testing patterns for Python — fixtures (session/module/function/factory), AAA structure, behavioral naming, coverage targets by code type, property-based testing with Hypothesis, and mutation testing with mutmut. Use when writing tests, designing fixtures, configuring coverage, or applying parametrize, async testing, or property-based strategies.

Use when working with Python tooling — uv package management, Hatchling build backend, ty or mypy type checker configuration, ruff linting, pre-commit hook setup, TOML read-write with tomlkit or tomllib, or PyPI packaging and release workflows. Routes to standalone specialist skills for deep dives on any single tool.

Auto-selects and enforces the strongest valid Python typing lane for the detected Python version and dependencies — no user input required. Use when adding or tightening type annotations, eliminating Any usage in internal code, designing boundary validators or parsers, choosing between stdlib typing (TypedDict, Protocol, dataclasses), Pydantic models, or Hypothesis property tests, addressing ty or mypy failures, or applying version-specific features (TypeIs, ReadOnly, PEP 695 generics, PEP 649 deferred evaluation). Enforces boundary isolation — raw payloads validated immediately at ingress and returned as typed internal objects.

Python web and API development enforcing strict route/domain/data layer separation, Pydantic v2 strict request-response models, edge-resolved auth, and async-safe HTTP clients. Use when working with FastAPI, Starlette, Django, Flask, HTTP endpoints, request models, authentication flows, async handlers, or any Python web framework task.

Reviews Python code across type safety, error handling, security, performance, modern patterns, design clarity, typed-boundary compliance, test quality, and documentation. Use when performing code review, PR review, pre-merge quality checks, or assessing Python for security vulnerabilities, bare except clauses, Any usage outside boundaries, or missing input validation at system boundaries.

Use when working with ruff — this skill's ruff policy and required overrides to Astral's official guidance. Pair with `astral:ruff` (if installed) for general usage.

Validates and corrects Python shebangs and PEP 723 inline script metadata by applying four shebang-selection rules. Use when auditing or fixing shebangs in Python files — choosing between plain python3 and the uv shebang for standalone scripts with external dependencies, adding or removing PEP 723 metadata blocks to match actual import requirements, checking execute bit presence, or avoiding redundant transitive dependencies when typer is declared.

Executes the implementation phase of the python-engineering stinkysnake modernization workflow. Use when stinkysnake phases 1-8 are complete — modernization plan reviewed, interfaces designed, and failing tests written. Implements functions in dependency order (types, data structures, utilities, core logic, integration, entry points) applying modern Python patterns (Protocol, dataclass, Pydantic, modern type annotations, httpx, orjson). Runs iterative pytest loops until all tests pass, then verifies with static analysis via prek or ruff. Success criteria — all tests pass, no type errors, no lint errors, coverage meets project threshold.

Routes Python engineering tasks to specialist skills by matching trigger patterns before any architecture, plan, or code is written. Use when working with Typer CLI frameworks, Rich or Textual terminal UIs, CLI UI/UX design, questionary prompts, FastMCP/MCP servers, ty type checker, uv package manager, Hatchling build backend, TOML editing, pre-commit/prek hooks, async Python, PyPI packaging, complex linting, technical debt modernization, testing workflows, feature development, or stdlib-only scripting.

Shared Python 3.11+ development rules — type safety and the boundary policy for `Any` (ty, native generics, Protocol, TypeIs, Pydantic), layered architecture and SOLID, error handling, security, performance, identifier naming, PEP 723 script dependencies, Rich/Typer output, tooling defaults (uv, ruff, ty, hatchling, pytest), and testing requirements (80% coverage, TDD). Activates when any Python skill or agent needs the shared rules for implementation, code review, refactoring, or test authoring.

Multi-phase Python quality improvement system for file paths passed as arguments. Runs prek/ruff/ty static analysis with auto-fixes, inventories Any types and typing gaps, plans Protocol/Generic/TypeGuard/TypedDict/dataclass modernization, forks a code-reviewer agent to critique the plan, refines the plan, discovers documentation changes, designs interfaces first, forks python-pytest-architect for failing tests, then hands off to snakepolish for implementation. Use when eliminating Any types, addressing technical debt, applying modern Python 3.11+ patterns, modernizing library usage (httpx, orjson), or refactoring for stronger type safety.

Establishes a dual-hypothesis investigation mindset for every test failure — treating failures as diagnostic signals that may indicate a real bug OR an incorrect test, never defaulting to automatic code changes or test dismissal. Use when encountering failing tests, debugging test errors, running a test suite that shows regressions, or any request involving "test failure analysis", "why is this test failing", or "should I fix the test or the code". Loads a 5-step protocol covering failure reading, implementation tracing, requirement context, reasoned decision-making, and learning extraction. Works alongside analyze-test-failures for detailed per-failure analysis and comprehensive-test-review for full suite review.

Use when building terminal UI apps with the Textual framework — creating widgets, screens, layouts, handling events, managing reactive attributes, testing with Pilot, snapshot testing with pytest-textual-snapshot, or running background workers. Covers App lifecycle, CSS styling, screen stack, custom messages, actions, bindings, and the Worker API.

Handles TOML configuration file operations in Python using tomlkit for comment-preserving read-modify-write cycles. Use when reading or writing pyproject.toml or any .toml config file, selecting between tomlkit and tomllib, modifying TOML while preserving comments and whitespace, implementing atomic config file updates, integrating TOML with Python dataclasses, handling TOML parse errors, or applying XDG base directory patterns for config file locations.

Use when working with ty — this skill's ty policy and required overrides to Astral's official guidance. Pair with `astral:ty` (if installed) for general usage.

Use when building CLI applications with Typer — creating commands, defining arguments and options with enum restrictions, path validation, date and UUID types, composing subcommands, testing with CliRunner, or using advanced features like colored output, progress bars, shell autocompletion, and version callbacks.

Use when building or debugging Typer/Rich CLI applications. Activates on Rich table rendering, console output in non-TTY environments, CliRunner testing with Rich output, snapshot testing, Typer command wiring, exception chain prevention with AppExit/AppExitRich patterns, table width at 80-column wrapping, Progress/Live in non-interactive contexts, stderr/stdout separation, or force_terminal vs width configuration. Grounds AI-generated CLI code in verified correctness patterns and prevents known Typer/Rich integration mistakes.

Use when working with uv — this skill's uv policy and required overrides to Astral's official guidance. Pair with `astral:uv` (if installed) for general usage.