Engineering KotlinCoroutinesJetpack Compose

Kotlin Specialist

Kotlin development: coroutines, flows, Jetpack Compose, multiplatform (KMP), Spring Boot with Kotlin, testing patterns, and migration from Java.

A Kotlin expert covering the full ecosystem: coroutines and structured concurrency, StateFlow/SharedFlow for reactive state, Jetpack Compose UI composition and recomposition optimization, and Kotlin Multiplatform for sharing business logic across Android, iOS, and desktop. Guides Java-to-Kotlin migrations and Spring Boot applications using Kotlin idioms.

Added Mar 20, 2026

$npx skills add johnefemer/skillfish --skill kotlin-specialist

Capabilities Real Examples Get Started Models & Context Works Great With

What This Skill Can Do

Concrete capabilities you get when you install this skill.

Design coroutine scopes, dispatchers, and structured concurrency hierarchies

Implement StateFlow and SharedFlow for reactive ViewModel patterns

Build performant Jetpack Compose UIs with stable types and derivedStateOf

Share domain logic across Android and iOS with Kotlin Multiplatform

Write Spring Boot endpoints idiomatically with Kotlin DSLs and extension functions

Migrate Java classes to idiomatic Kotlin incrementally with null safety

Real Conversations

See how the Kotlin Specialist skill responds to actual requests. These are representative examples of what your AI agent will produce.

You

I'm building an Android app repository layer that fetches from a REST API and caches in Room. How should I structure the coroutines and handle errors cleanly?

Agent

Use the offline-first pattern with a sealed Result type for clean error propagation:

sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val exception: Throwable) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao,
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
) {
    fun getUser(id: String): Flow<Result<User>> = flow {
        emit(Result.Loading)

        // Emit cached data immediately
        dao.getUserById(id)?.let { emit(Result.Success(it)) }

        // Fetch fresh data
        try {
            val fresh = withContext(ioDispatcher) { api.getUser(id) }
            dao.upsert(fresh.toEntity())
            emit(Result.Success(fresh.toDomain()))
        } catch (e: IOException) {
            emit(Result.Error(e)) // only emits error if no cache available, or in addition to it
        }
    }
}

// ViewModel consumes with structured scope
class UserViewModel(private val repo: UserRepository) : ViewModel() {
    val userState: StateFlow<Result<User>> = repo.getUser(userId)
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), Result.Loading)
}

The SharingStarted.WhileSubscribed(5000) keeps the flow alive 5 seconds after the last subscriber — surviving screen rotations without re-fetching.

You

My Jetpack Compose list screen recomposes every item on any state change. I have 50 items and it's noticeably slow on older devices.

Agent

Compose recomposes any composable that reads state that changed. For lists, the issue is almost always unstable types or reading too-broad state.

1. Make list item types stable:

// ❌ Compose can't prove this is stable (contains a List field)
data class User(val id: String, val name: String, val tags: List<String>)

// ✅ Annotate as stable if properties only change when the data changes
@Stable
data class User(val id: String, val name: String, val tags: List<String>)
// OR use ImmutableList from kotlinx.collections.immutable
data class User(val id: String, val name: String, val tags: ImmutableList<String>)

2. Use a key for LazyColumn items:

LazyColumn {
    items(users, key = { user -> user.id }) { user ->
        UserCard(user = user) // only recomposes if this user's data changed
    }
}

3. Avoid reading list state inside item composables:

// ❌ selectedIds.contains() reads from mutable state — recomposes ALL items on selection change
@Composable
fun UserCard(user: User, selectedIds: Set<String>) {
    val isSelected = selectedIds.contains(user.id) // reads whole set
}

// ✅ Derive selection state before passing into the composable
@Composable
fun UserCard(user: User, isSelected: Boolean) { ... }
// In parent: isSelected = user.id in selectedIds

4. Profile with Layout Inspector → Recomposition counts to confirm which composables are firing before and after your fix.

Get Started

How to install and use this skill in your preferred environment.

Skills are designed for AI coding agents (Claude Code, Cursor, Windsurf) and IDE-based workflows where the agent can read files, run scripts, and act on your codebase.

Models & Context

Which AI models and context windows work best with this skill.

Recommended Models

Claude Sonnet 4 or GPT-4o for Kotlin/Compose patterns. KMP APIs are evolving — cross-check with kotlinlang.org for the latest multiplatform target configuration.

Context Window

SKILL.md ~5KB. Fits in 32K context; KMP project structures with shared and platform modules benefit from 64K+.

Pro tips for best results

1

Be specific

Include numbers — users, budget, RPS — so the skill can size the architecture.

2

Share constraints

Compliance needs, team size, and existing stack all improve the output.

3

Iterate

Start with a high-level design, then ask follow-ups for IaC, cost analysis, or security review.

4

Combine skills

Pair with companion skills below for end-to-end coverage.

Works Great With

These skills complement Kotlin Specialist for end-to-end coverage. Install them together for better results.

Senior Backend

REST APIs, database optimization, authentication, and microservices.

BackendAPIs

Mobile Developer

Cross-platform mobile development: React Native and Flutter patterns, native bridge design, offline-first architecture, push notifications, and app store deployment.

React NativeFlutter

Java Architect

Enterprise Java: Spring Boot 3, virtual threads (Project Loom), records, pattern matching, GraalVM native images, and modernization strategies.

JavaSpring Boot

TDD Guide

Test-driven development workflow with test generation and multi-framework support.

TDDTesting

$ skillfish add johnefemer/skillfish --all # install all skills at once

Ready to try Kotlin Specialist?

Install the skill and start getting expert-level guidance in your workflow — any agent, any IDE.