К основному содержанию
скилл CX Codex

kotlin-expert — скилл для Claude Code: что делает и как установить

Скилл kotlin-expert помогает писать и разбирать Kotlin-код для Android, корутин, JVM и Kotlin Multiplatform. Подключайте его к задачам, где важны идиоматичный синтаксис и архитектура.

Apache-2.0 203 установок ★ 45 обновлён 2026-10-12

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add personamanagmentlayer/pcl --skill kotlin-expert -a claude-code
Открыть на GitHub

Что делает kotlin-expert

kotlin-expert разбирает основы Kotlin: null safety, extension functions, data classes, sealed classes, higher-order functions, корутины и Flow. Он также ориентирован на Android-разработку с Jetpack Compose, ViewModel, LiveData, Room, Retrofit и Hilt.

Для Kotlin Multiplatform скилл охватывает общую бизнес-логику, платформенные реализации и модули для iOS и Android. В примерах есть StateFlow, viewModelScope, параллельная загрузка через async и awaitAll(), фильтрация Flow, Compose-экраны и DAO для Room.

Скилл доступен в Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI и OpenCode. Он работает с чтением, записью и изменением файлов, а команды kotlin и gradle разрешены через Bash. Для Android-проектов это значит, что рекомендации затрагивают жизненный цикл, UI, локальную базу и асинхронный код.

Какие задачи решает

  • разобрать null safety и sealed classes в Kotlin
  • собрать экран на Jetpack Compose
  • организовать загрузку данных через корутины и Flow
  • описать DAO и сущности для Room
  • разделить код Kotlin Multiplatform по платформам

Примеры запросов агенту

  • Разбери этот Kotlin-код и предложи исправления для null safety и sealed classes.
  • Собери экран списка пользователей на Jetpack Compose с ViewModel и StateFlow.
  • Организуй параллельную загрузку пользователей через корутины и awaitAll().

Как установить kotlin-expert

1Через Skills CLI (Vercel)

npx skills add personamanagmentlayer/pcl --skill kotlin-expert -a claude-code

2Вручную: положить файлы

~/.claude/skills/kotlin-expert/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/kotlin-expert/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о kotlin-expert

Как установить kotlin-expert в Claude Code?

Выполните npx skills add personamanagmentlayer/pcl --skill kotlin-expert -a claude-code, затем проверьте файл ~/.claude/skills/kotlin-expert/SKILL.md.

Что делает kotlin-expert?

Скилл помогает с Kotlin Fundamentals, Android, корутинами, Flow, Kotlin Multiplatform и современным JVM-кодом. Он также разбирает Jetpack Compose, Room и архитектуру с общими модулями.

С какими платформами работает kotlin-expert?

Скилл доступен для Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI и OpenCode.

Исходный текст

SKILL.md · Apache-2.0
---
name: kotlin-expert
version: 1.1.0
description: >-
  Expert-level Kotlin development, Android, coroutines, and multiplatform. Use when the
  user mentions Android, coroutines, multiplatform, or JVM, or when the task involves
  Kotlin Fundamentals, Android Development, Kotlin Multiplatform, or Kotlin Style.
category: languages
tags: [kotlin, android, coroutines, multiplatform, jvm]
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash(kotlin:*, gradle:*)
---

# Kotlin Expert

Expert guidance for Kotlin development, Android, coroutines, Kotlin Multiplatform, and modern JVM development.

## Core Concepts

### Kotlin Fundamentals

- Null safety
- Extension functions
- Data classes
- Sealed classes
- Coroutines and Flow
- Higher-order functions

### Android Development

- Jetpack Compose
- ViewModel and LiveData
- Room database
- Retrofit networking
- Dependency injection (Hilt)
- Android lifecycle

### Kotlin Multiplatform

- Shared business logic
- Platform-specific implementations
- iOS and Android targets
- Common module architecture

## Modern Kotlin Syntax

```kotlin
// Data classes
data class User(
    val id: String,
    val name: String,
    val email: String,
    val createdAt: LocalDateTime = LocalDateTime.now()
)

// Sealed classes for type-safe states
sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    object Loading : Result<Nothing>()
}

// Extension functions
fun String.isValidEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// Scope functions
fun processUser(user: User) {
    user.run {
        println("Processing user: $name")
        // 'this' refers to user
    }

    user.let { u ->
        // 'it' or custom name refers to user
        println(u.email)
    }

    user.apply {
        // Modify properties
        // Returns the object
    }
}

// Null safety
fun findUser(id: String): User? {
    return database.find(id)
}

val user = findUser("123")
val name = user?.name ?: "Unknown" // Elvis operator
user?.let { println(it.name) } // Safe call with let

// When expression
fun getUserStatus(user: User): String = when {
    user.isActive && user.isPremium -> "Premium Active"
    user.isActive -> "Active"
    else -> "Inactive"
}
```

## Coroutines and Flow

```kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

class UserRepository {
    private val api: UserApi

    // Suspend function
    suspend fun fetchUser(id: String): User {
        return withContext(Dispatchers.IO) {
            api.getUser(id)
        }
    }

    // Flow for reactive streams
    fun observeUsers(): Flow<List<User>> = flow {
        while (true) {
            val users = fetchUsers()
            emit(users)
            delay(5000) // Refresh every 5 seconds
        }
    }.flowOn(Dispatchers.IO)

    // StateFlow for state management
    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    suspend fun refreshUsers() {
        _users.value = fetchUsers()
    }
}

// Coroutine scopes
class UserViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadUsers() {
        viewModelScope.launch {
            try {
                val users = repository.fetchUser("123")
                // Update UI
            } catch (e: Exception) {
                // Handle error
            }
        }
    }

    // Parallel execution
    suspend fun loadMultipleUsers(ids: List<String>): List<User> {
        return coroutineScope {
            ids.map { id ->
                async { repository.fetchUser(id) }
            }.awaitAll()
        }
    }

    // Flow transformation
    fun searchUsers(query: String): Flow<List<User>> {
        return repository.observeUsers()
            .map { users -> users.filter { it.name.contains(query, ignoreCase = true) } }
            .distinctUntilChanged()
            .debounce(300)
    }
}
```

## Android Jetpack Compose

```kotlin
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier

@Composable
fun UserListScreen(viewModel: UserViewModel = viewModel()) {
    val users by viewModel.users.collectAsState()
    val isLoading by viewModel.isLoading.collectAsState()

    Scaffold(
        topBar = { TopAppBar(title = { Text("Users") }) }
    ) { padding ->
        if (isLoading) {
            CircularProgressIndicator(
                modifier = Modifier.fillMaxSize()
            )
        } else {
            LazyColumn(
                modifier = Modifier.padding(padding)
            ) {
                items(users) { user ->
                    UserCard(user = user)
                }
            }
        }
    }
}

@Composable
fun UserCard(user: User) {
    Card(
        modifier = Modifier
            .fillMaxWidth()
            .padding(8.dp)
    ) {
        Column(modifier = Modifier.padding(16.dp)) {
            Text(
                text = user.name,
                style = MaterialTheme.typography.headlineSmall
            )
            Text(
                text = user.email,
                style = MaterialTheme.typography.bodyMedium
            )
        }
    }
}
```

## Room Database

```kotlin
import androidx.room.*
import kotlinx.coroutines.flow.Flow

@Entity(tableName = "users")
data class UserEntity(
    @PrimaryKey val id: String,
    @ColumnInfo(name = "name") val name: String,
    @ColumnInfo(name = "email") val email: String,
    @ColumnInfo(name = "created_at") val createdAt: Long
)

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsers(): Flow<List<UserEntity>>

    @Query("SELECT * FROM users WHERE id = :userId")
    suspend fun getUserById(userId: String): UserEntity?

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertUser(user: UserEntity)

    @Update
    suspend fun updateUser(user: UserEntity)

    @Delete
    suspend fun deleteUser(user: UserEntity)

    @Query("DELETE FROM users WHERE id = :userId")
    suspend fun deleteUserById(userId: String)
}

@Database(entities = [UserEntity::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao

    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null

        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}
```

## Dependency Injection with Hilt

```kotlin
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {

    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    @Provides
    @Singleton
    fun provideUserApi(retrofit: Retrofit): UserApi {
        return retrofit.create(UserApi::class.java)
    }
}

@HiltAndroidApp
class MyApplication : Application()

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    @Inject lateinit var repository: UserRepository
}
```

## Kotlin Multiplatform

```kotlin
// commonMain
expect class Platform() {
    val name: String
}

expect fun platformSpecificFunction(): String

// androidMain
actual class Platform actual constructor() {
    actual val name: String = "Android ${android.os.Build.VERSION.SDK_INT}"
}

actual fun platformSpecificFunction(): String = "Android implementation"

// iosMain
actual class Platform actual constructor() {
    actual val name: String = UIDevice.currentDevice.systemName()
}

actual fun platformSpecificFunction(): String = "iOS implementation"

// Shared business logic
class UserService {
    suspend fun fetchUser(id: String): User {
        // Shared logic works on all platforms
        return api.getUser(id)
    }
}
```

## Best Practices

### Kotlin Style

- Use val over var when possible
- Leverage null safety features
- Use data classes for DTOs
- Prefer extension functions
- Use sealed classes for type-safe states
- Follow naming conventions

### Coroutines

- Use appropriate dispatchers (IO, Main, Default)
- Handle cancellation properly
- Avoid GlobalScope
- Use structured concurrency
- Prefer Flow over LiveData
- Use StateFlow for state

### Android

- Follow MVVM architecture
- Use Jetpack Compose for UI
- Implement proper lifecycle handling
- Use dependency injection
- Handle configuration changes
- Implement proper error handling

## Anti-Patterns

❌ Using !! (non-null assertion)
❌ GlobalScope.launch
❌ Blocking main thread
❌ Not handling coroutine cancellation
❌ Tight coupling
❌ God classes
❌ Ignoring memory leaks

## Resources

- Kotlin Docs: https://kotlinlang.org/docs/
- Android Developers: https://developer.android.com/kotlin
- Kotlin Coroutines: https://kotlinlang.org/docs/coroutines-overview.html
- Jetpack Compose: https://developer.android.com/jetpack/compose

© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl

Похожие скиллы

Все скиллы по теме «Языки программирования» →
kotlin-specialist VoltAgent Субагент kotlin-specialist для задач на Kotlin в JVM-сервисах и Android. Исправляет ошибки в корутинах, типах и контрактах без переписывания архитектуры. CX Codex ★ 6 505звёзд репо appwrite-kotlin appwrite Скилл appwrite-kotlin подсказывает агенту, как писать код на Kotlin SDK Appwrite: авторизация, база, файлы, realtime и серверные админ-вызовы. CX Codex +1 916установок kotlin-tooling-kotlin-toolchain github:@singleton11 Скилл kotlin-tooling-kotlin-toolchain для Claude Code и других IDE, который подключается при сборке, запуске, тестировании и настройке Kotlin/Java-проектов через Kotlin Toolchain (JetBrains, в альфе). CX Codex +1 753установок kotlin-coroutines-flows affaan-m Скилл kotlin-coroutines-flows подсказывает паттерны Kotlin Coroutines и Flow для Android и KMP. Пригодится при отладке отмены, параллельных задач и тестов. CX Codex +1 6 700установок android-kotlin alinaqi Скилл android-kotlin для Claude Code помогает писать Android-код на Kotlin с Coroutines, Jetpack Compose, Hilt и MockK. Он подключается при работе с Kotlin-файлами и Gradle-конфигурацией. CX Codex +1 3 400установок kotlin-concurrency-and-flow chrisbanes Скилл kotlin-concurrency-and-flow для ревью и написания Kotlin-кода с корутинами: разбирает владение scope, отмену, StateFlow, SharedFlow и Channel. CX Codex +1 1 500установок

Из того же набора104

Весь набор →
testing-expert Скилл testing-expert задаёт агенту правила написания тестов: структура AAA, независимые кейсы, моки и граничные случаи. Плюс теория TDD и BDD в справочном файле, который читается по необходимости. CX Codex +1 206установок sre-expert Скилл sre-expert для настройки практик SRE, расчёта SLO и организации процессов инцидент-менеджмента в проекте. CX Codex +1 205установок elasticsearch-expert Скилл elasticsearch-expert помогает проектировать маппинги Elasticsearch, настраивать поисковые запросы, агрегации и оптимизировать работу ELK-стека. CX Codex +1 205установок prometheus-expert Скилл prometheus-expert для Claude Code учит агента мониторингу Prometheus: сбору метрик, запросам PromQL, recording и alerting rules. Помогает поднимать экспортёры в Kubernetes и разбирать чужие дашборды. CX Codex +1 204установок react-expert Скилл react-expert настраивает ИИ-агента на разработку на React 18+ и Next.js: правила типизации в TypeScript, хуки, мемоизацию и тесты на React Testing Library. CX Codex +1 200установок performance-expert Скилл performance-expert помогает профилировать код, искать узкие места в базах данных и настраивать кэширование под высокие нагрузки. CX Codex +1 198установок javascript-expert Скилл javascript-expert для Claude Code задаёт агенту роль опытного JavaScript-разработчика и правила стиля для проектов на ES2024+, Node.js и npm. CX Codex +1 197установок stockbreeder-expert Скилл stockbreeder-expert для Claude Code добавляет Python-модели и инструкции для учёта скота, племенной работы, мониторинга здоровья животных и графиков вакцинации в агропроектах. CX Codex +1 195установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой