async-concurrency_skill

Overview

This skill is an Async Concurrency Expert that prevents waterfall-style waits and maximizes parallelization in API and frontend logic. It applies disciplined async patterns to reduce latency, increase throughput, and make async flows easier to reason about. The skill is geared for Python-centric stacks but the principles apply across languages and runtimes.

How this skill works

The skill inspects code paths for sequential awaits of independent tasks and recommends refactors into parallel execution (e.g., gather, create_task, Promise.all equivalents). It analyzes dependency graphs to start independent or dependent tasks efficiently and moves awaits as late as possible so work can run concurrently. It reports refactor outcomes and flags places where blocking awaits introduce unnecessary latency.

When to use it

• When multiple independent API calls are awaited one after another causing serial latency
• When a long-running background task can run alongside other work but is awaited too early
• When conditional branches await data only needed in that branch
• When tasks have partial dependencies and can be started together to overlap I/O
• When optimizing frontend data fetching to reduce perceived load time

Best practices

• Never await independent tasks sequentially; use asyncio.gather or create_task to run concurrently
• Start dependent and independent tasks together when possible, then await results selectively
• Defer awaits until the value is actually required; move I/O out of the critical path
• Prefer explicit task management (create_task, futures) for long-lived or background work
• Log refactors and improvements with a clear marker such as 'Waterfall Eliminated' for traceability

Example use cases

• Refactor backend endpoints that fetch multiple third-party resources sequentially into concurrent fetches to reduce tail latency
• Optimize frontend data layer to initiate all independent queries on page load and await only needed results for rendering
• Convert blocking orchestration code into dependency-aware concurrent tasks so CPU and I/O overlap
• Introduce background tasks for telemetry or caching without delaying the main response
• Audit async-heavy modules to produce a prioritized list of waterfall chains for targeted fixes