Generate Robust Kotlin Coroutine Code

This skill implements Kotlin coroutines - asynchronous programming, structured concurrency, and reactive data flows in Android and backend applications. The core rule is always using proper coroutine scopes for cancellation and lifecycle management (a SupervisorJob plus a chosen Dispatchers combined into a CoroutineScope, with an explicit cleanup() cancelling it). Dispatcher selection is explicit: Dispatchers.Main for UI updates, Dispatchers.IO for network/disk operations, Dispatchers.Default for CPU-intensive work, and Dispatchers.Unconfined for testing only.

Use it when Android or backend code needs structured concurrency, cancellation-safe scopes, and reactive Flow pipelines - not raw callbacks or unscoped coroutine launches.

class UserRepository {
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)

    suspend fun fetchUserData(userId: String): Result<User> {
        return withContext(Dispatchers.IO) {
            try {
                val user = apiService.getUser(userId)
                Result.success(user)
            } catch (e: Exception) {
                Result.failure(e)
            }
        }
    }

    fun cleanup() {
        scope.cancel()
    }
}

Android patterns include a ViewModel driving a MutableStateFlow UI state through viewModelScope.launch, mapping onSuccess/onFailure results to Loading/Success/Error states. Flow-based streams show a location-updates flow {} builder emitting on an interval with flowOn(Dispatchers.IO), filtered by accuracy and deduplicated with distinctUntilChanged, with catch handling stream errors. Error handling covers a DataSyncService launching syncUsers(), syncPosts(), and syncComments() as independent children inside a SupervisorJob-backed supervisorScope, so one sync failing doesn't cancel the others, plus a generic retryWithExponentialBackoff helper combining withTimeout and increasing delay between attempts up to a max. Advanced Flow operations are shown in a WeatherRepository: combine() merges location, user preferences, and current-user streams into a single request, flatMapLatest turns that into a weather-API call, and retry(3) retries transient failures while explicitly excluding UnauthorizedException from the retry; a second method merges a one-shot cached database read with the live combined stream via merge() and distinctUntilChanged() for a cache-with-fallback pattern.

Testing uses a StandardTestDispatcher inside runTest, launching the coroutine under test and advancing virtual time with advanceTimeBy() before verifying mock interactions and cancelling the job.

Android and Kotlin backend developers who need concrete structured-concurrency, Flow, and retry patterns rather than ad-hoc coroutine launches. Performance guidance recommends channelFlow for complex producers, buffer() for backpressure, shareIn()/stateIn() for hot flows, Dispatchers.IO.limitedParallelism(n) for resource-bound work, and async with awaitAll() for parallel independent operations. Common pitfalls to avoid are named directly: never use GlobalScope in production, don't swallow CancellationException, avoid blocking calls without proper context switching, don't create unnecessary intermediate flows, and always handle exceptions in flow collectors.