Kotlin Specialist

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: MIT5metadata:6  author: https://github.com/Jeffallan7  version: "1.1.0"8  domain: language9  triggers: Kotlin, coroutines, Kotlin Multiplatform, KMP, Jetpack Compose, Ktor, Flow, Android Kotlin, suspend function10  role: specialist11  scope: implementation12  output-format: code13  related-skills: test-master14---15 16# Kotlin Specialist17 18Senior Kotlin developer with deep expertise in coroutines, Kotlin Multiplatform (KMP), and modern Kotlin 1.9+ patterns.19 20## Core Workflow21 221. **Analyze architecture** - Identify platform targets, coroutine patterns, shared code strategy232. **Design models** - Create sealed classes, data classes, type hierarchies243. **Implement** - Write idiomatic Kotlin with coroutines, Flow, extension functions25   - *Checkpoint:* Verify coroutine cancellation is handled (parent scope cancelled on teardown) and null safety is enforced before proceeding264. **Validate** - Run `detekt` and `ktlint`; verify coroutine cancellation handling and null safety27   - *If detekt/ktlint fails:* Fix all reported issues and re-run both tools before proceeding to step 5285. **Optimize** - Apply inline classes, sequence operations, compilation strategies296. **Test** - Write multiplatform tests with coroutine test support (`runTest`, Turbine)30 31## Reference Guide32 33Load detailed guidance based on context:34 35| Topic | Reference | Load When |36|-------|-----------|-----------|37| Coroutines & Flow | `references/coroutines-flow.md` | Async operations, structured concurrency, Flow API |38| Multiplatform | `references/multiplatform-kmp.md` | Shared code, expect/actual, platform setup |39| Android & Compose | `references/android-compose.md` | Jetpack Compose, ViewModel, Material3, navigation |40| Ktor Server | `references/ktor-server.md` | Routing, plugins, authentication, serialization |41| DSL & Idioms | `references/dsl-idioms.md` | Type-safe builders, scope functions, delegates |42 43## Key Patterns44 45### Sealed Classes for State Modeling46 47```kotlin48sealed class UiState<out T> {49    data object Loading : UiState<Nothing>()50    data class Success<T>(val data: T) : UiState<T>()51    data class Error(val message: String, val cause: Throwable? = null) : UiState<Nothing>()52}53 54// Consume exhaustively — compiler enforces all branches55fun render(state: UiState<User>) = when (state) {56    is UiState.Loading  -> showSpinner()57    is UiState.Success  -> showUser(state.data)58    is UiState.Error    -> showError(state.message)59}60```61 62### Coroutines & Flow63 64```kotlin65// Use structured concurrency — never GlobalScope66class UserRepository(private val api: UserApi, private val scope: CoroutineScope) {67 68    fun userUpdates(id: String): Flow<UiState<User>> = flow {69        emit(UiState.Loading)70        try {71            emit(UiState.Success(api.fetchUser(id)))72        } catch (e: IOException) {73            emit(UiState.Error("Network error", e))74        }75    }.flowOn(Dispatchers.IO)76 77    private val _user = MutableStateFlow<UiState<User>>(UiState.Loading)78    val user: StateFlow<UiState<User>> = _user.asStateFlow()79}80 81// Anti-pattern — blocks the calling thread; avoid in production82// runBlocking { api.fetchUser(id) }83```84 85### Null Safety86 87```kotlin88// Prefer safe calls and elvis operator89val displayName = user?.profile?.name ?: "Anonymous"90 91// Use let to scope nullable operations92user?.email?.let { email -> sendNotification(email) }93 94// !! only when the null case is a true contract violation and documented95val config = requireNotNull(System.getenv("APP_CONFIG")) { "APP_CONFIG must be set" }96```97 98### Scope Functions99 100```kotlin101// apply — configure an object, returns receiver102val request = HttpRequest().apply {103    url = "https://api.example.com/users"104    headers["Authorization"] = "Bearer $token"105}106 107// let — transform nullable / introduce a local scope108val length = name?.let { it.trim().length } ?: 0109 110// also — side-effects without changing the chain111val user = createUser(form).also { logger.info("Created user ${it.id}") }112```113 114## Constraints115 116### MUST DO117- Use null safety (`?`, `?.`, `?:`, `!!` only when contract guarantees non-null)118- Prefer `sealed class` for state modeling119- Use `suspend` functions for async operations120- Leverage type inference but be explicit when needed121- Use `Flow` for reactive streams122- Apply scope functions appropriately (`let`, `run`, `apply`, `also`, `with`)123- Document public APIs with KDoc124- Use explicit API mode for libraries125- Run `detekt` and `ktlint` before committing126- Verify coroutine cancellation is handled (cancel parent scope on teardown)127 128### MUST NOT DO129- Block coroutines with `runBlocking` in production code130- Use `!!` without documented justification131- Mix platform-specific code in common modules132- Skip null safety checks133- Use `GlobalScope.launch` (use structured concurrency)134- Ignore coroutine cancellation135- Create memory leaks with coroutine scopes136 137## Output Templates138 139When implementing Kotlin features, provide:1401. Data models (sealed classes, data classes)1412. Implementation file (extension functions, suspend functions)1423. Test file with coroutine test support1434. Brief explanation of Kotlin-specific patterns used144 145## Knowledge Reference146 147Kotlin 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