review-concurrency_skill

Overview

This skill performs concurrency and thread-safety-focused code reviews for multi-threaded, coroutine, and async code. It highlights defects that cause races, deadlocks, livelocks, and incorrect thread usage. The output classifies findings by severity and gives actionable remediation steps.

How this skill works

The skill inspects code paths that access shared mutable state, synchronization primitives, and concurrency APIs. It looks for unprotected read-modify-write sequences, inconsistent lock ordering, blocking calls under locks, coroutine leaks, and incorrect dispatcher usage. Each finding is mapped to a severity level and accompanied by targeted recommendations.

When to use it

• Review pull requests that introduce threading, coroutines, or async/await logic
• Audit code that manipulates shared mutable state or global caches
• Assess performance fixes that change synchronization or locking
• Validate new libraries that alter execution context or use background threads
• Before release when stability under load is required

Best practices

• Prefer immutable data or thread-safe collections to reduce locking needs
• Use fine-grained locking and document lock acquisition order to avoid deadlocks
• Prefer atomic operations for simple counters and flags instead of coarse locks
• Ensure coroutine scopes are structured and cancellations are propagated
• Avoid blocking calls while holding locks; use timeouts and non-blocking alternatives

Example use cases

• Detect a TOCTOU bug in a config check followed by a write without synchronization
• Flag nested synchronized blocks with inconsistent ordering that can deadlock under load
• Find coroutines launched in global scope that can leak and outlive lifecycle owners
• Identify UI updates performed off the main thread or DB operations on the main thread
• Recommend replacing shared mutable maps with concurrent map implementations