Results for “async”

Convert a meeting into async work that actually decides — the doc-plus-deadline format that replaces the room, the comment-window rules, the decision-closure step that async usually fumbles, and the honest test for what still needs synchronous. Use when asked can this meeting be async, replace our status meeting with a doc, run this decision without a call, or async isn't working for us. Produces the conversion design, the async artifact format, the closure protocol, and the still-needs-a-room list.

The English summary is being prepared. Showing the original description.

Find Python input/output calls that may stall asynchronous backend work, then fix or guard each relevant path with runtime tests. Verify that tests fail when blocking behavior returns and pass after the fix is restored.

• Checking asynchronous Python changes before a pull request
• Triaging blocking input/output across the codebase
• Adding tests for cleanup and error branches

Structure Python code to release files and database connections reliably, including when errors occur. Covers context managers, which handle setup and cleanup, asynchronous resources, nested cleanup, and streaming responses that retain accumulated state.

• Releasing database connections when errors occur
• Cleaning up files and temporary files
• Creating asynchronous context managers

Write and review asynchronous C++ networking code using Boost.Asio or standalone Asio. The skill selects an implementation style for the installed library and C++ version, then checks memory lifetimes, concurrent writes, error handling, and build settings.

• Implementing asynchronous TCP or UDP servers and clients
• Reviewing buffer lifetimes and concurrent socket writes
• Adapting networking code to older Boost and C++ versions

Build Python 3.11+ applications with type annotations, asynchronous operations, and structured error handling. The skill also creates pytest tests and checks code with mypy, black, and ruff to support consistent implementation and validation.

• Add type annotations and strict type checking
• Implement asynchronous network or file operations
• Create pytest tests with fixtures and mocks

Write, review, and debug Rust applications, including ownership and borrowing rules that govern memory use. Covers trait-based APIs, explicit error handling, asynchronous work with tokio, and tests with Cargo validation.

• Resolve ownership, borrowing, and lifetime errors
• Design APIs with traits
• Implement asynchronous tasks with tokio

Deploy SageMaker endpoints, the services that answer model requests, with automatic capacity scaling, CloudWatch alarms, and resource tags. Supports real-time and asynchronous inference, scaling down to zero instances, deployment checks, and resource cleanup.

• Deploying a real-time model endpoint
• Scaling a sparse workload down to zero instances
• Running long inference jobs asynchronously

Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code.

The English summary is being prepared. Showing the original description.

Write correct async Python runtime code with explicit blocking-I/O boundaries, cancellation, and timeout handling. Use when editing `asyncio` workflows, background loops, async services, or mixed sync/async integrations.

The English summary is being prepared. Showing the original description.

Reviews tokio async runtime usage for task management, sync primitives, channel patterns, and runtime configuration. Covers Rust 2024 edition changes including async fn in traits, RPIT lifetime capture, LazyLock, and if-let temporary scoping. Use when reviewing Rust code that uses tokio, async/await patterns, spawn, channels, or async synchronization. Also covers tokio-util, tower, and hyper integration patterns.

The English summary is being prepared. Showing the original description.

Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when the task involves `async Rust`, `Tokio patterns`, `Rust concurrent programming`, `async traits`, or `Rust futures and streams`.

The English summary is being prepared. Showing the original description.

Raise real concurrency in asyncio LLM batch scorers built on the OpenAI SDK (AsyncOpenAI, including OpenAI-compatible providers like DeepSeek). Use when: (1) raising an asyncio.Semaphore above ~100 produces no throughput gain, (2) a batch pipeline saturates near 100 in-flight requests despite a larger semaphore, (3) planning a high-concurrency campaign against a provider with no hard rate limit (DeepSeek v4-flash tolerates 2000+ in flight). Root cause: AsyncOpenAI's default httpx pool caps max_connections at 100, silently bottlenecking any larger semaphore — you must pass a custom http_client with httpx.Limits sized to the semaphore.

The English summary is being prepared. Showing the original description.

Master Rust async programming with Tokio, async traits, error handling, and concurrent patterns. Use when building async Rust applications, implementing concurrent systems, or debugging async code.

The English summary is being prepared. Showing the original description.

Write Rust unit, integration, and async tests using a test-first workflow. Covers generated test inputs, mock dependencies, performance benchmarks, and coverage checks to assess behavior and identify code that remains untested.

• Developing Rust functions with tests first
• Adding tests to existing code
• Testing async operations and timeouts

Build and review Nuxt 4 applications with consistent server and browser rendering. Guide data fetching, page rendering and caching rules, and deferred loading to address rendering mismatches and improve performance.

• Debugging differences between server and browser rendering
• Reviewing page data fetching with useFetch and useAsyncData
• Choosing rendering and caching rules for each route group

Build Python integrations with crypto exchanges using CCXT. Get guidance on fetching prices and order books, placing orders, checking balances, and receiving live updates, with examples for authentication, error handling, and synchronous or asynchronous code.

• Fetch exchange data for analysis
• Implement order placement in a trading bot
• Monitor live prices and order books

Build and review C#/.NET APIs and business backends using concrete implementation patterns. Cover asynchronous operations, service dependencies, database access, configuration, caching, and tests to structure application code and examine quality and performance issues.

• Designing a new .NET Web API
• Reviewing asynchronous C# code
• Improving database access and caching

Create or modify Handsontable cell validators, functions that check whether input values are valid. Covers empty values, asynchronous callbacks that return validation results, access to cell settings, validator registration, and pitfalls involving dropdown behavior and corrected values.

• Creating a custom cell validation rule
• Reviewing empty values and asynchronous validation
• Checking dropdown validation in never-selected cells

Write and review Rust code with clear ownership, reference lifetimes, asynchronous tasks, and explicit error handling. Use types to prevent invalid states, reduce unnecessary copying, and document the safety requirements of necessary unsafe operations.

• Resolving ownership and reference lifetime issues
• Building asynchronous tasks with tokio
• Preventing invalid states through type design

Work with Rust async runtimes — Tokio, async-std, executor internals, pinning, wakers, and building high-performance async Rust services.

The English summary is being prepared. Showing the original description.

Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.

The English summary is being prepared. Showing the original description.

Python asyncio patterns for concurrent programming. Triggers on: asyncio, async, await, coroutine, gather, semaphore, TaskGroup, event loop, aiohttp, concurrent.

The English summary is being prepared. Showing the original description.

Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.

The English summary is being prepared. Showing the original description.

Comprehensive guidance for implementing asynchronous Python applications using asyncio, concurrent programming patterns, and async/await for building high-performance, non-blocking systems.

The English summary is being prepared. Showing the original description.