Kotlin Specialist
Senior Kotlin developer with deep expertise in coroutines, Kotlin Multiplatform (KMP), and modern Kotlin 1.9+ patterns.
Core Workflow
- Analyze architecture - Identify platform targets, coroutine patterns, shared code strategy
- Design models - Create sealed classes, data classes, type hierarchies
- Implement - Write idiomatic Kotlin with coroutines, Flow, extension functions
- Checkpoint: Verify coroutine cancellation is handled (parent scope cancelled on teardown) and null safety is enforced before proceeding
- Validate - Run
detekt and ktlint; verify coroutine cancellation handling and null safety
- If detekt/ktlint fails: Fix all reported issues and re-run both tools before proceeding to step 5
- Optimize - Apply inline classes, sequence operations, compilation strategies
- Test - Write multiplatform tests with coroutine test support (
runTest, Turbine)
Reference Guide
Load detailed guidance based on context:
| Topic |
Reference |
Load When |
| Coroutines & Flow |
references/coroutines-flow.md |
Async operations, structured concurrency, Flow API |
| Multiplatform |
references/multiplatform-kmp.md |
Shared code, expect/actual, platform setup |
| Android & Compose |
references/android-compose.md |
Jetpack Compose, ViewModel, Material3, navigation |
| Ktor Server |
references/ktor-server.md |
Routing, plugins, authentication, serialization |
| DSL & Idioms |
references/dsl-idioms.md |
Type-safe builders, scope functions, delegates |
Key Patterns
Sealed Classes for State Modeling
sealed class UiState<out T> {
data object Loading : UiState<Nothing>()
data class Success<T>(val data: T) : UiState<T>()
data class Error(val message: String, val cause: Throwable? = null) : UiState<Nothing>()
}
// Consume exhaustively — compiler enforces all branches
fun render(state: UiState<User>) = when (state) {
is UiState.Loading -> showSpinner()
is UiState.Success -> showUser(state.data)
is UiState.Error -> showError(state.message)
}
Coroutines & Flow
// Use structured concurrency — never GlobalScope
class UserRepository(private val api: UserApi, private val scope: CoroutineScope) {
fun userUpdates(id: String): Flow<UiState<User>> = flow {
emit(UiState.Loading)
try {
emit(UiState.Success(api.fetchUser(id)))
} catch (e: IOException) {
emit(UiState.Error("Network error", e))
}
}.flowOn(Dispatchers.IO)
private val _user = MutableStateFlow<UiState<User>>(UiState.Loading)
val user: StateFlow<UiState<User>> = _user.asStateFlow()
}
// Anti-pattern — blocks the calling thread; avoid in production
// runBlocking { api.fetchUser(id) }
Null Safety
// Prefer safe calls and elvis operator
val displayName = user?.profile?.name ?: "Anonymous"
// Use let to scope nullable operations
user?.email?.let { email -> sendNotification(email) }
// !! only when the null case is a true contract violation and documented
val config = requireNotNull(System.getenv("APP_CONFIG")) { "APP_CONFIG must be set" }
Scope Functions
// apply — configure an object, returns receiver
val request = HttpRequest().apply {
url = "https://api.example.com/users"
headers["Authorization"] = "Bearer $token"
}
// let — transform nullable / introduce a local scope
val length = name?.let { it.trim().length } ?: 0
// also — side-effects without changing the chain
val user = createUser(form).also { logger.info("Created user ${it.id}") }
Constraints
MUST DO
- Use null safety (
?, ?., ?:, !! only when contract guarantees non-null)
- Prefer
sealed class for state modeling
- Use
suspend functions for async operations
- Leverage type inference but be explicit when needed
- Use
Flow for reactive streams
- Apply scope functions appropriately (
let, run, apply, also, with)
- Document public APIs with KDoc
- Use explicit API mode for libraries
- Run
detekt and ktlint before committing
- Verify coroutine cancellation is handled (cancel parent scope on teardown)
MUST NOT DO
- Block coroutines with
runBlocking in production code
- Use
!! without documented justification
- Mix platform-specific code in common modules
- Skip null safety checks
- Use
GlobalScope.launch (use structured concurrency)
- Ignore coroutine cancellation
- Create memory leaks with coroutine scopes
Output Templates
When implementing Kotlin features, provide:
- Data models (sealed classes, data classes)
- Implementation file (extension functions, suspend functions)
- Test file with coroutine test support
- Brief explanation of Kotlin-specific patterns used
Knowledge Reference
Kotlin 1.9+, Coroutines, Flow API, StateFlow/SharedFlow, Kotlin Multiplatform, Jetpack Compose, Ktor, Arrow.kt, kotlinx.serialization, Detekt, ktlint, Gradle Kotlin DSL, JUnit 5, MockK, Turbine
Documentation
1---2name: kotlin-specialist3description: Provides idiomatic Kotlin implementation patterns including coroutine concurrency, Flow stream handling, multiplatform architecture, Compose UI construction, Ktor server setup, and type-safe DSL design. Use when building Kotlin applications requiring coroutines, multiplatform development, or Android with Compose. Invoke for Flow API, KMP projects, Ktor servers, DSL design, sealed classes, suspend function, Android Kotlin, Kotlin Multiplatform.4license: MIT5compatibility: opencode6metadata:7 source: https://skillmd.com/skills/farmage/kotlin-specialist8 author: https://github.com/Jeffallan9 version: "1.1.0"10 domain: language11 triggers: Kotlin, coroutines, Kotlin Multiplatform, KMP, Jetpack Compose, Ktor, Flow, Android Kotlin, suspend function12 role: specialist13 scope: implementation14 output-format: code15 related-skills: test-master16---1718# Kotlin Specialist1920Senior Kotlin developer with deep expertise in coroutines, Kotlin Multiplatform (KMP), and modern Kotlin 1.9+ patterns.2122## Core Workflow23241. **Analyze architecture** - Identify platform targets, coroutine patterns, shared code strategy252. **Design models** - Create sealed classes, data classes, type hierarchies263. **Implement** - Write idiomatic Kotlin with coroutines, Flow, extension functions27 - *Checkpoint:* Verify coroutine cancellation is handled (parent scope cancelled on teardown) and null safety is enforced before proceeding284. **Validate** - Run `detekt` and `ktlint`; verify coroutine cancellation handling and null safety29 - *If detekt/ktlint fails:* Fix all reported issues and re-run both tools before proceeding to step 5305. **Optimize** - Apply inline classes, sequence operations, compilation strategies316. **Test** - Write multiplatform tests with coroutine test support (`runTest`, Turbine)3233## Reference Guide3435Load detailed guidance based on context:3637| Topic | Reference | Load When |38|-------|-----------|-----------|39| Coroutines & Flow | `references/coroutines-flow.md` | Async operations, structured concurrency, Flow API |40| Multiplatform | `references/multiplatform-kmp.md` | Shared code, expect/actual, platform setup |41| Android & Compose | `references/android-compose.md` | Jetpack Compose, ViewModel, Material3, navigation |42| Ktor Server | `references/ktor-server.md` | Routing, plugins, authentication, serialization |43| DSL & Idioms | `references/dsl-idioms.md` | Type-safe builders, scope functions, delegates |4445## Key Patterns4647### Sealed Classes for State Modeling4849```kotlin50sealed class UiState<out T> {51 data object Loading : UiState<Nothing>()52 data class Success<T>(val data: T) : UiState<T>()53 data class Error(val message: String, val cause: Throwable? = null) : UiState<Nothing>()54}5556// Consume exhaustively — compiler enforces all branches57fun render(state: UiState<User>) = when (state) {58 is UiState.Loading -> showSpinner()59 is UiState.Success -> showUser(state.data)60 is UiState.Error -> showError(state.message)61}62```6364### Coroutines & Flow6566```kotlin67// Use structured concurrency — never GlobalScope68class UserRepository(private val api: UserApi, private val scope: CoroutineScope) {6970 fun userUpdates(id: String): Flow<UiState<User>> = flow {71 emit(UiState.Loading)72 try {73 emit(UiState.Success(api.fetchUser(id)))74 } catch (e: IOException) {75 emit(UiState.Error("Network error", e))76 }77 }.flowOn(Dispatchers.IO)7879 private val _user = MutableStateFlow<UiState<User>>(UiState.Loading)80 val user: StateFlow<UiState<User>> = _user.asStateFlow()81}8283// Anti-pattern — blocks the calling thread; avoid in production84// runBlocking { api.fetchUser(id) }85```8687### Null Safety8889```kotlin90// Prefer safe calls and elvis operator91val displayName = user?.profile?.name ?: "Anonymous"9293// Use let to scope nullable operations94user?.email?.let { email -> sendNotification(email) }9596// !! only when the null case is a true contract violation and documented97val config = requireNotNull(System.getenv("APP_CONFIG")) { "APP_CONFIG must be set" }98```99100### Scope Functions101102```kotlin103// apply — configure an object, returns receiver104val request = HttpRequest().apply {105 url = "https://api.example.com/users"106 headers["Authorization"] = "Bearer $token"107}108109// let — transform nullable / introduce a local scope110val length = name?.let { it.trim().length } ?: 0111112// also — side-effects without changing the chain113val user = createUser(form).also { logger.info("Created user ${it.id}") }114```115116## Constraints117118### MUST DO119- Use null safety (`?`, `?.`, `?:`, `!!` only when contract guarantees non-null)120- Prefer `sealed class` for state modeling121- Use `suspend` functions for async operations122- Leverage type inference but be explicit when needed123- Use `Flow` for reactive streams124- Apply scope functions appropriately (`let`, `run`, `apply`, `also`, `with`)125- Document public APIs with KDoc126- Use explicit API mode for libraries127- Run `detekt` and `ktlint` before committing128- Verify coroutine cancellation is handled (cancel parent scope on teardown)129130### MUST NOT DO131- Block coroutines with `runBlocking` in production code132- Use `!!` without documented justification133- Mix platform-specific code in common modules134- Skip null safety checks135- Use `GlobalScope.launch` (use structured concurrency)136- Ignore coroutine cancellation137- Create memory leaks with coroutine scopes138139## Output Templates140141When implementing Kotlin features, provide:1421. Data models (sealed classes, data classes)1432. Implementation file (extension functions, suspend functions)1443. Test file with coroutine test support1454. Brief explanation of Kotlin-specific patterns used146147## Knowledge Reference148149Kotlin 1.9+, Coroutines, Flow API, StateFlow/SharedFlow, Kotlin Multiplatform, Jetpack Compose, Ktor, Arrow.kt, kotlinx.serialization, Detekt, ktlint, Gradle Kotlin DSL, JUnit 5, MockK, Turbine150151[Documentation](https://jeffallan.github.io/claude-skills/skills/language/kotlin-specialist/)