247 skills · sorted by relevance
Guide Swift 6.2 migration and concurrency design using MainActor, which keeps related work on the main actor. Address data-race compiler errors, protocol conformance, and explicit background execution for heavy computations through @concurrent.
Build concurrent Go applications with goroutines, lightweight execution units, and channels for communication. Apply patterns for worker pools, cancellation, synchronization, and orderly shutdown, and investigate race conditions when concurrent operations access shared data.
Build Python applications that handle other work while waiting for network or database operations. Use asyncio and async/await to run tasks concurrently, manage errors and timeouts, and handle cancellation with appropriate cleanup.
Build Go services and command-line tools with clear interfaces, explicit error handling, and concurrent tasks using goroutines and channels. Use pprof to investigate performance, then check behavior with benchmarks, structured test cases, fuzzing, and race detection.
Plan database schema and data changes for production systems. Use staged column replacements, concurrent index creation, and batched data updates to limit disruption, with migration workflows for PostgreSQL, Prisma, Drizzle, Kysely, Django, and golang-migrate.
Measure performance in the agentic-flow worker system, including trigger detection, agent selection, caching, and concurrent operations. Run a full suite or individual benchmarks to compare response times and resource usage against configured targets.
Reproduce timing and ordering bugs in a CTF sandbox using controlled concurrent requests. Compare normal and racing runs, trace reads and writes, and preserve a minimal sequence that demonstrates duplicate actions or inconsistent state.
Build and debug asynchronous Rust applications with Tokio, a runtime for scheduling work while operations wait. Apply patterns for task management, channels, error handling, cancellation, and concurrency limits when developing network services and other concurrent systems.
Model distributed systems and concurrent algorithms in TLA+ or PlusCal, then check possible states with TLC. Use the results to investigate deadlocks, broken rules, and differences between specifications and implementation code.
Fix PostgreSQL deadlock errors caused by concurrent schema initialization in worker processes. Use when: (1) psycopg2.errors.DeadlockDetected during CREATE INDEX/TABLE IF NOT EXISTS, (2) Multiple Cloud Run jobs, Kubernetes pods, or worker processes start simultaneously, (3) Error shows "Process X waits for RowExclusiveLock... blocked by process Y", (4) init_schema() or migration code runs at worker startup. The key insight: "IF NOT EXISTS" is NOT truly concurrent-safe - PostgreSQL still acquires locks that can deadlock.
The English summary is being prepared. Showing the original description.
Organize a task into parallel work streams with clear dependencies, separate places for changes, and explicit checks. Batch independent reads and tests, coordinate concurrent work, and report completed or blocked tasks with verification results.
Write, review, and refactor Go applications using established language conventions. The skill covers error handling, concurrent tasks, interfaces, package structure, memory use, and development commands to support clear, maintainable code.
Implement distributed data synchronization with CRDTs, data structures designed to merge concurrent updates. Covers counters, sets, shared values, and sequences, with incremental updates and tracking of dependencies between operations.
Take implementation work through small, independently mergeable pull requests. Use a separate working directory for each PR, record manual QA evidence, write English review descriptions, resolve CI and review findings, then merge and clean up.
Design agents that respond to incoming emails, external notifications, and timers. Plan how they handle interruptions, prioritize new requests, track concurrent tasks, and deliver results while longer operations continue in the background.
Build Python applications that keep other tasks moving while waiting for network, database, or file operations. Guides the choice of asyncio patterns, with timeouts, cancellation, error handling, and testing for asynchronous code.
Design storage for event sourcing, an approach that records changes as events. Compare database options and plan event ordering, duplicate handling, concurrent writes, and scaling to build a consistent event persistence layer.
Review C# asynchronous code and get suggestions for method names, return types, exception handling, concurrent tasks, and cancellation. Identify blocking calls and missing awaits, and choose patterns for long operations or sequences processed asynchronously.
Analyze LLM serving traces to identify GPU time usage, opportunities to run operations concurrently, and known patterns for combining operations. Produce three consistent tables from saved traces or live captures on supported servers.
Build Python applications that keep other tasks moving while waiting for network, file, or database operations. The skill guides asyncio patterns, task cancellation, timeouts, workload limits, and testing for asynchronous APIs, scrapers, and background processing.
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.
Helps choose and tune Cloud Storage FUSE mounts, which expose bucket objects through file paths. It covers cache sizing, training performance, checkpoint write safety, and cost diagnosis on GKE, Compute Engine, and Cloud Run.
Run concurrent Omnigent conversations with real hosts and runners while replacing the LLM with a zero-latency mock. Read the generated report to explain response-time distributions, throughput, and failures, helping assess Omnigent's own processing overhead.
Compare batching, request scheduling, and memory management for a single model serving instance. Assess concurrent request capacity, response times, generation speed, and GPU time per result that meets the required quality and deadline.