async-expert_skill

Overview

This skill is an expert in asynchronous programming patterns across languages (Python asyncio, JavaScript/TypeScript promises, C# async/await, Rust futures). It helps design, review, and implement concurrent code with attention to correctness, performance, cancellation, and resource safety. Use it to convert blocking code to non-blocking, implement retries/timeouts, and harden async flows against race conditions and leaks.

How this skill works

I inspect async control flow, concurrency primitives, error handling, and resource cleanup in the target language and propose patterns or code that follow established APIs. Before producing code I verify API signatures and behavior against official docs when uncertainty exists, and I recommend tests and validations to catch concurrency bugs. The skill provides concrete patterns: parallel execution, bounded concurrency, timeouts/cancellation, retries with backoff, and executor offloading for blocking work.

When to use it

• You need safe parallel execution without cancelling sibling tasks on single failures.
• You must add timeouts, cancellation, or graceful shutdown to async workflows.
• You want to convert blocking libraries to async-friendly code or use executors.
• You need backpressure, concurrency limits, or resource pooling for high-throughput services.
• You are designing tests that assert concurrency behavior and race conditions.

Best practices

• Verify official async API docs and exact method signatures before implementing.
• Write failing async tests first (TDD) to exercise concurrency, timeouts, and cancellations.
• Prefer structured concurrency or task groups where available to avoid orphaned tasks.
• Limit concurrency with semaphores or worker pools to avoid overwhelming services.
• Never block the event loop; run CPU-bound work in an executor or separate process.
• Always handle and propagate async errors; ensure cleanup in finally/cleanup handlers.

Example use cases

• Implement fetchUsersParallel that returns successes and failures without aborting other requests.
• Add fetchWithTimeout that cancels slow requests and returns a safe fallback instead of throwing.
• Add a bounded processor using semaphores to process large queues with a max concurrency.
• Convert sync HTTP calls to aiohttp/fetch with AbortController or run_in_executor patterns.
• Implement retryWithBackoff for flaky downstream services with jitter and max delay caps.