Top 10 Python Foundation Workflows for AI Coding Agents

Best for: Day-to-day idiomatic Python

python-patterns gives an agent a compact set of everyday Python choices. Its core idiom is EAFP, or asking forgiveness after an operation raises an exception, rather than checking every condition before attempting the operation. The skill also points agents toward modern built-in generic syntax, so annotations can use the current forms provided by Python's built-in collection types.

The source puts generator expressions and comprehensions alongside readable PEP 8 structure. That combination helps an agent choose a concise expression for a collection or lazy sequence while keeping the surrounding code easy to scan.

• EAFP as the default error-handling idiom
• Modern generic syntax for built-in collection types
• Generator expressions and comprehensions
• Readable structure aligned with PEP 8

Best for: Python layout and module boundaries

python-project-structure helps an agent decide between a src layout and a flat layout, then organize modules around that decision. Its guidance includes module organization, the use of __all__, cohesion, circular dependency avoidance, and test directories. Those details give a repository change a place to live before an agent creates a new import path.

Use this skill when an agent is adding a package, moving modules, or investigating an import problem that may come from the project layout. Clear module boundaries give later implementation decisions a stable surface.

• src layout and flat layout guidance
• Module organization and __all__
• Cohesion and circular dependency avoidance
• Dedicated test directory structure

Best for: Type annotations, structural interfaces, and mypy or pyright configuration

python-type-safety is a focused typing workflow for Python changes that need an explicit, checkable interface. It covers annotations, generic classes, protocols for structural interfaces, and narrowing and type guards for values whose runtime shape needs verification.

Use it when adding annotations to an existing project, defining a reusable generic API, or configuring mypy or pyright. Its strict-checking guidance recommends incremental adoption for existing projects rather than treating every repository as immediately ready for strict mode.

• Annotations for public signatures
• Generics and structural interfaces with Protocol
• Type narrowing and guards
• Incremental strict mypy or pyright adoption

Best for: I/O concurrency and sync versus async choices

async-python-patterns covers the pieces an agent must keep aligned in asynchronous Python: event loops, coroutines, tasks, and futures. Its coordination patterns include gather, TaskGroup, semaphores, locks, and queues. These constructs give concurrent work an explicit lifecycle and let the agent choose a bounded pattern when several operations share a resource.

The source also emphasizes nonblocking I/O and the decision between synchronous and asynchronous code. A coroutine that is created without being awaited can produce the warning `coroutine was never awaited`; blocking work inside an async path can stall the event loop.

• Event loops, coroutines, tasks, and futures
• gather and TaskGroup coordination
• Semaphores, locks, and queues
• Nonblocking I/O and sync versus async choice

Best for: Runtime errors and input validation

python-error-handling gives an agent a failure policy for ordinary Python runtime work. It starts with fail-fast input validation, then uses a custom exception hierarchy to express the kinds of failure a caller can handle. The source covers raise from so an error can preserve its originating cause while adding the context of the current operation.

The skill also handles partial failures in batches and context managers. Those cases need an explicit choice about the work that completed, the work that failed, and the resources that must be released.

• Fail-fast input validation
• Custom exception hierarchies
• raise from for chained causes and context
• Partial batch failures and context managers

Best for: Modular designs and tangled Python code

python-design-patterns is a design pass for a Python service or component that is gaining responsibilities. Its starting point is KISS and the single-responsibility principle, then it uses composition over inheritance and the rule of three to keep an abstraction tied to demonstrated need.

Use it when a class is becoming a God object, a module boundary is unclear, or a refactor must make I/O and business logic independently testable. It is about changing the shape of code, not choosing a framework.

• KISS and single-responsibility boundaries
• Composition before inheritance
• Rule of three for earned abstractions
• Layering that keeps I/O independently testable

Best for: Repeatable dependencies and one-off Python scripts

python-uv gives an agent one dependency-management workflow: add and remove project requirements with uv, synchronize the locked environment, and run a script through uv rather than relying on an activated environment by accident.

Its guidance also covers PEP 723-style inline script metadata. Use it when a standalone script needs declared dependencies or when a project change must leave a reproducible dependency state behind.

• uv add, remove, and sync for project dependencies
• Locked environments kept in sync
• uv run for dependency-aware scripts
• Inline metadata for standalone scripts

Best for: Project-wide lint, format, and type-check setup

python-code-quality is an orchestration guide for a Python quality stack. It keeps Ruff linting, Ruff formatting, and ty type checking as distinct tools while showing how to run them together in pre-commit and CI.

Use it when a project needs a coherent feedback gate rather than a one-off formatter or linter setting. Its routing table points focused questions back to the right underlying tool instead of treating every quality concern as the same task.

• Separate ownership for linting, formatting, and types
• Ruff plus ty in one quality gate
• Pre-commit and CI wiring
• Routing to focused tool-specific guidance

Best for: Pytest suites, fixtures, mocks, and TDD

python-testing centers Python verification on pytest and test-driven development. It calls for descriptive, independent tests using Arrange-Act-Assert, fixtures for setup and teardown, and parameterization when several cases express the same behavior.

The source also distinguishes unit, integration, and property-based checks, then covers mocks and coverage reporting. Use it when an agent needs to define what a Python change must keep true before or after implementation.

• Arrange-Act-Assert and descriptive test names
• Fixtures and parameterization
• Unit, integration, and property-based checks
• Mocks, assertions, and coverage reporting

Best for: Slow Python paths and memory pressure

python-performance-optimization starts with evidence: CPU, memory, line-level, and production profiling identify where a Python program actually spends its budget. Its guidance keeps execution time, memory use, CPU utilization, and I/O wait as separate signals.

Once the bottleneck is known, it covers data-structure choices, caching, batching I/O, generators, and appropriate parallelism. The source explicitly warns against optimizing code that has not been profiled.

• CPU, memory, line-level, and production profiling
• Measure execution time, memory, CPU, and I/O wait
• Caching, batching, generators, and parallelism
• Profile before optimizing a hot path