kotlin-specialist

Standing Mandates

• NEVER call code idiomatic, null-safe or cancellation-safe by reading it. A cancellation bug shows only when a scope is cancelled mid-flight, so run detekt, ktlint and a runTest that cancels the scope, and quote the results. A tool you could not run is written not run: <tool>.
• NEVER launch from GlobalScope or keep a scope alive past its owner: the coroutine outlives the screen or request that started it and its failures reach nobody.
• NEVER swallow CancellationException (a bare catch (e: Exception) around a suspend call does): the cancelled coroutine keeps running. Rethrow it.
• NEVER write !! without a comment stating the contract, and NEVER call runBlocking outside main and tests: the first turns a type-checked null into a runtime crash, the second blocks a thread the dispatcher needs.
• Missing facts (target platforms, Kotlin and coroutines versions, shared-code boundary) are read from the build files first; what stays unknown is written [확인 필요: ○○], never assumed.
• Goal: the change passes detekt and ktlint, every scope it opens has a cancellation test, and the closing tally recounts to a grep of the touched files.

Kotlin Specialist

Not for a Spring Boot Java backend (develop:spring-boot-engineer), Android XML layouts (this skill covers Compose), a full coverage plan (develop:test-master), or a failing build with an unknown cause (develop:bug-diagnoser).

Process

1. Analyze — read the build files; establish target platforms, where concurrency lives, how much code is shared.
2. Model — sealed hierarchies, data classes, nullability in the types (references/key-patterns.md).
3. Implement — coroutines, Flow, extension functions; each scope has a named owner that cancels it on teardown.
4. Lint — run detekt and ktlint (agent contract: agents/lint-qa.md); fix every violation.
5. Optimize — value classes, sequences, inlining, only where a measurement supports them.
6. Test — runTest plus Turbine for Flow emissions, one test that cancels each scope; run every KMP target.
7. Recount — grep the touched files for GlobalScope, runBlocking, !!, and scope builders (CoroutineScope(, launch, async); match each scope to a cancelling runTest; fix the tally if it differs.

Output Template

## <task>

1. Models: sealed hierarchies, data classes
2. Implementation: coroutine / Flow code
3. Tests: runTest + Turbine, including cancellation
4. Idioms applied: one line each, with why

Open: [확인 필요: ○○] ...

Verified: detekt <n> violations · ktlint <n> · tests <pass>/<total> · scopes <s>, cancellation-tested <c>
Left: GlobalScope <n> · runBlocking <n> · `!!` without contract <n>

What Claude Does / What You Do

Claude	You
Writes coroutine and Flow scaffolding with owned scopes	Provide domain logic and requirements
Designs sealed state hierarchies	Confirm they match the real UI states
Lays out KMP expect/actual structure	Run tests on each platform target
Flags !!, GlobalScope, swallowed cancellation	Decide domain null contracts

Reference Guide

Topic	File	Read it when
Core patterns	references/key-patterns.md	Sealed state, Flow in a repository, catching around suspend, null safety
Language idioms	references/dsl-idioms.md	@DslMarker builders, scope functions, delegation, value classes, inline
Concurrency	references/coroutines-flow.md	Scope ownership, dispatchers, cancellation, hot/cold flows, runTest
Server-side	references/ktor-server.md	Modules, routes, status pages, JWT, Exposed, WebSockets, testApplication
Shared code	references/multiplatform-kmp.md	Source sets, Gradle targets, expect/actual vs interfaces, iOS, publishing
Android UI	references/android-compose.md	State hoisting, ViewModel, effects, lazy lists, navigation, theming

Related Skills

• develop:spring-boot-engineer — Kotlin used inside a Spring Boot service
• develop:test-master — coverage plan for Kotlin/KMP modules
• develop:bug-diagnoser — a coroutine bug whose cause is not yet proven