Implement High-Performance Async Python

This skill covers implementing asynchronous Python applications using asyncio, concurrent programming patterns, and async/await for high-performance, non-blocking systems. Its process: clarify workload characteristics (I/O-bound vs CPU-bound), targets, and runtime constraints; pick concurrency patterns (tasks, gather, queues, pools) with clear cancellation rules; add timeouts, backpressure, and structured error handling; and include testing/debugging guidance for async code paths. A detailed implementation playbook (resources/implementation-playbook.md) covers deeper patterns and examples.

Use this when building async web APIs (FastAPI, aiohttp, Sanic), implementing concurrent I/O operations (database, file, network), building web scrapers with concurrent requests, developing real-time applications (WebSocket servers, chat systems), processing multiple independent tasks simultaneously, building microservices with async communication, optimizing I/O-bound workloads, or implementing async background tasks and queues.

Not the right skill when the workload is CPU-bound with minimal I/O (asyncio won't help there - consider multiprocessing instead), a simple synchronous script is sufficient, or the runtime environment can't support an asyncio event loop.

Inputs: the target workload's I/O vs CPU characteristics, concurrency targets, and runtime constraints.

Outputs: a chosen concurrency pattern (tasks, gather, queues, or pools) with defined cancellation rules, timeouts, backpressure handling, structured error handling, and guidance for testing and debugging the async code paths.

Python asyncio, and async frameworks/libraries like FastAPI, aiohttp, and Sanic.

Python developers building I/O-bound, concurrent, or real-time systems who need correct asyncio patterns - cancellation, timeouts, backpressure - rather than a naive synchronous implementation.