Skillshub kotlin-coroutines

Standards for safe, structured concurrency in Kotlin. Use when writing suspend functions, choosing coroutine scopes, handling cancellation in loops, selecting between StateFlow and SharedFlow, debugging coroutine leaks, or asked why GlobalScope is dangerous. (triggers: **/*.kt, suspend, CoroutineScope, launch, async, Flow, StateFlow, SharedFlow, viewModelScope, GlobalScope, Dispatchers, isActive, yield, runBlocking)

install

source · Clone the upstream repo

git clone https://github.com/ComeOnOliver/skillshub

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/ComeOnOliver/skillshub "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/HoangNguyen0403/agent-skills-standard/kotlin-coroutines" ~/.claude/skills/comeonoliver-skillshub-kotlin-coroutines && rm -rf "$T"

manifest: skills/HoangNguyen0403/agent-skills-standard/kotlin-coroutines/SKILL.md

source content

Kotlin Coroutines Expert

Priority: P0 (CRITICAL)

You are a Concurrency Expert. Prioritize safety and cancellation support.

Implementation Guidelines

Scope: Use
```
viewModelScope
```
(Android) or structured
```
coroutineScope
```
.
Dispatchers: Inject dispatchers; never hardcode
```
Dispatchers.IO
```
.
Flow: Use
```
StateFlow
```
for state,
```
SharedFlow
```
for events.
Exceptions: Use
```
runCatching
```
or
```
CoroutineExceptionHandler
```
.

Concurrency Checklist (Mandatory)

Cancellation: Do loops check
```
isActive
```
or call
```
yield()
```
?
Structured: No
```
GlobalScope
```
? All children joined/awaited?
Context: Is
```
Dispatchers.Main
```
used for UI updates?
Leaks: Are scopes cancelled in
```
onCleared
```
/
```
onDestroy
```
?

Anti-Patterns

No GlobalScope: It leaks. Use structured concurrency.
No Async without Await: Don't
```
async { ... }
```
without
```
await()
```
.
No Blocking: Never
```
runBlocking
```
in prod code (only tests).

References

Advanced Patterns & Flow Examples