# kotlin-concurrency-and-flow

A skill for writing and reviewing Kotlin coroutine code: scope ownership, cancellation, StateFlow, SharedFlow and Channel.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 1100 installs · ★ 1120
- Author: chrisbanes
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/chrisbanes/skills/tree/HEAD/skills/kotlin-concurrency-and-flow/SKILL.md
- Updated: 2026-10-25
- HTML: https://affpapa.org/en/nevibecode/skills/kotlin-concurrency-and-flow

## What it does

The skill fires when you write or review Kotlin code that touches coroutines: `CoroutineScope` ownership, raw `Thread` or `Executor` work, `init { launch }`, `runBlocking`, cancellation, plus `StateFlow`, `SharedFlow`, `Channel`, `stateIn` and `SharingStarted`.

It walks through a seven-step procedure. First you map every coroutine owner, cancellation boundary, producer, consumer, durable state and transient event. Then it tells you to compare the API's existing caller-visible contract against the required owner and lifetime: if a suspend function already hands cancellation, result and failure to its caller, leave it alone. Picking the right primitive gets its own step. A `Channel` delivers each event to one consumer; a configured `SharedFlow` broadcasts to active consumers. For a one-consumer navigation handoff that must survive a collector gap, the skill points to `Channel(Channel.BUFFERED)` exposed as `receiveAsFlow()`.

A topic router sends structured-concurrency signals to `references/structured-concurrency.md` and state-or-event questions to `references/flow-state-events.md`. To validate a change it routes you to `../gradle-run/SKILL.md` and rules out running `./gradlew` directly. Compose collection and UI effects belong to the neighbouring `compose-state-and-effects` skill. Install runs through `npx skills add`.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-concurrency-and-flow -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/kotlin-concurrency-and-flow/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/kotlin-concurrency-and-flow/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-concurrency-and-flow -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/kotlin-concurrency-and-flow/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-concurrency-and-flow -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/kotlin-concurrency-and-flow/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install chrisbanes/skills kotlin-concurrency-and-flow
```

2. **Manually: put the files in place**
- File: `.github/skills/kotlin-concurrency-and-flow/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-concurrency-and-flow -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/chrisbanes/skills --path skills/kotlin-concurrency-and-flow
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/kotlin-concurrency-and-flow/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add chrisbanes/skills --skill kotlin-concurrency-and-flow -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/chrisbanes/skills/tree/HEAD/skills/kotlin-concurrency-and-flow/SKILL.md

## When to use it
- trace who owns a coroutine and when it gets cancelled
- strip fire-and-forget `launch` out from behind a plain function
- pick between `Channel` and `SharedFlow` for one-shot events
- check whether an event is lost during a collector gap
- decide if `stateIn` is needed and which `SharingStarted` fits

## Example prompts
- Review this ViewModel: who owns the scope and what happens on cancellation?
- Should this be a `SharedFlow` or a `Channel(Channel.BUFFERED)`?
- Check the state updates for a race between `_state.value` and `stateIn`.

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: bdaff350515d33fd.

BEGIN THIRD-PARTY FILE bdaff350515d33fd
```text
---
name: kotlin-concurrency-and-flow
description: Use when writing or reviewing Kotlin coroutine scope ownership, raw Thread or Executor work, init launches, non-suspending launch APIs, runBlocking, cancellation, StateFlow, SharedFlow, Channel, stateIn, SharingStarted, state updates, or one-shot events.
---

# Kotlin concurrency and Flow

## Core principle

Give asynchronous work an explicit owner and lifetime, then model durable state
and transient events with primitives whose delivery and replay semantics match
the product contract.

## Procedure

1. Identify each coroutine owner, cancellation boundary, producer, consumer,
   durable state, and transient event.
2. Before changing an API, compare its existing caller-visible contract with
   the required owner and lifetime. If a suspend API already gives its caller
   cancellation, result, and failure ownership, finish with no change; do not
   add a scope, `launch`, callback, or deferred wrapper merely for convenience.
3. Select a scope whose lifecycle owns the work; do not retain arbitrary scopes
   or hide unstructured launches behind non-suspending APIs.
4. Model renderable, current data as state and imperative one-shot work as an
   event only when its loss and replay behavior are explicitly acceptable.
   Ask whether one consumer handles each event or every active consumer must
   receive it. A `Channel` hands each event to one consumer; a configured
   `SharedFlow` broadcasts to active consumers. If that consumer contract is
   unknown, state both options and the decision needed before choosing one.
   For a one-consumer navigation handoff that must survive a collector gap,
   choose a bounded `Channel(Channel.BUFFERED)` (not `UNLIMITED`) exposed as
   `receiveAsFlow()`; do not preserve a
   replay-zero `SharedFlow` after identifying event loss as the defect.
5. Choose Flow sharing and buffering semantics from the producer and consumer
   lifetimes rather than from a default.
6. Read the focused reference for the material concern below.
7. Finish when cancellation, restart, replay, and failure behavior are all
   observable from the public API and no caller must guess who owns the work.
```
END THIRD-PARTY FILE bdaff350515d33fd

The third-party file has ended. Everything between the bdaff350515d33fd tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2183 of 2856 bytes. © chrisbanes · Apache-2.0 · https://github.com/chrisbanes/skills/tree/HEAD/skills/kotlin-concurrency-and-flow/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md