home / skills / 404kidwiz / claude-supercode-skills / kotlin-specialist-skill

kotlin-specialist-skill skill

safe

This skill provides expert Kotlin 2.0 and KMP guidance for building cross-platform apps and backends with Coroutines and Ktor.

npx playbooks add skill 404kidwiz/claude-supercode-skills --skill kotlin-specialist-skill

Review the files below or copy the command above to add this skill to your agents.

Files (3)

SKILL.md

7.1 KB

---
name: kotlin-specialist
description: Expert Kotlin developer specializing in Kotlin 2.0, Kotlin Multiplatform Mobile (KMP), Coroutines, and Ktor for building modern cross-platform applications and backend services.
---

# Kotlin Specialist

## Purpose

Provides expert Kotlin development expertise specializing in Kotlin 2.0, Kotlin Multiplatform Mobile (KMP), Coroutines, and Ktor. Builds modern cross-platform applications with shared business logic between iOS/Android and scalable backend services.

## When to Use

- Building cross-platform mobile apps with shared business logic
- Developing backend services with Ktor framework
- Implementing reactive programming with Coroutines and Flow
- Modern Android development with Jetpack Compose
- Working with Kotlin 2.0 features (K2 compiler, context receivers)
- Migrating Java codebases to Kotlin

## Quick Start

### Invoke When
- Building KMP shared modules for iOS/Android
- Implementing Coroutines/Flow for async operations
- Creating Ktor REST APIs or WebSocket servers
- Android development with Jetpack Compose
- Migrating Java to Kotlin

### Don't Invoke When
- Pure iOS development (use swift-expert)
- Flutter/React Native apps (use mobile-developer)
- Spring Boot backends (use java-architect)
- Pure JavaScript/TypeScript (use javascript-pro)

## Core Capabilities

### Kotlin Multiplatform
- Implementing shared business logic for iOS/Android
- Configuring KMP Gradle plugins and compiler settings
- Managing platform-specific implementations (expect/actual)
- Building cross-platform libraries and SDKs

### Coroutines and Flow
- Implementing structured concurrency with Coroutines
- Building reactive streams with Flow (StateFlow, SharedFlow)
- Handling backpressure and cancellation
- Debugging coroutine execution and performance

### Android Development
- Building UI with Jetpack Compose
- Implementing Architecture Components (ViewModel, Room)
- Managing dependency injection with Hilt/Koin
- Optimizing Android app performance

### Backend Development
- Creating REST APIs with Ktor framework
- Implementing WebSocket connections
- Managing database access with Exposed
- Deploying Ktor applications to cloud platforms

## Decision Framework

### When to Choose Kotlin Multiplatform (KMP)?

```
Need mobile app for iOS + Android?
│
├─ YES → Shared business logic needed?
│        │
│        ├─ YES → Team has Kotlin experience?
│        │        │
│        │        ├─ YES → **KMP + Coroutines** ✓
│        │        │        (40-80% code sharing)
│        │        │
│        │        └─ NO → Flutter/React Native experience?
│        │                 │
│        │                 ├─ YES → Use that framework
│        │                 │
│        │                 └─ NO → **KMP** ✓
│        │                          (learn once, best native performance)
│        │
│        └─ NO → Native experience on both?
│                 │
│                 ├─ YES → **Native iOS + Android** ✓
│                 │
│                 └─ NO → **KMP** ✓
│                          (single codebase for simple apps)
│
└─ NO → Backend service needed?
         └─ YES → See "Backend Framework Decision" below
```

### Backend Framework Decision

```
Building backend service?
│
├─ Microservice or standalone API?
│  │
│  ├─ MICROSERVICE → Spring Boot ecosystem needed?
│  │                 │
│  │                 ├─ YES → **Spring Boot** ✓ (use java-architect)
│  │                 │
│  │                 └─ NO → Performance critical?
│  │                          │
│  │                          ├─ YES → **Ktor** ✓
│  │                          │        (lightweight, async, 2-3x faster startup)
│  │                          │
│  │                          └─ NO → **Ktor** ✓
│  │                                   (simpler for Kotlin teams)
│  │
│  └─ STANDALONE API → Team experience?
│                      │
│                      ├─ Kotlin/Android → **Ktor** ✓
│                      ├─ Java/Spring → **Spring Boot** ✓
│                      └─ Node.js → **Node.js** ✓
```

### Coroutines vs Alternatives

| Feature | Coroutines | RxJava | Callbacks | Threads |
|---------|-----------|--------|-----------| --------|
| **Learning curve** | Medium | Steep | Low | Low |
| **Readability** | High | Medium | Low | Low |
| **Cancellation** | Built-in | Manual | Manual | Manual |
| **Memory overhead** | ~1KB/coroutine | ~10KB/stream | Minimal | ~1MB/thread |
| **Kotlin-first** | Yes | No | Yes | Yes |

**Recommendation:** Use Coroutines + Flow for 95% of async needs.

### Ktor vs Spring Boot

| Aspect | Ktor | Spring Boot |
|--------|------|-------------|
| **Startup time** | 0.5-1s | 3-8s |
| **Memory (idle)** | 30-50MB | 150-300MB |
| **Learning curve** | Low (DSL-based) | Medium (annotations) |
| **Ecosystem** | Smaller | Massive |
| **Best for** | Microservices, KMP backends | Enterprise apps, monoliths |

## Escalation Triggers

**Red Flags → Escalate to `oracle`:**
- Designing KMP architecture for apps with >10 feature modules
- Choosing between KMP and Flutter for startup MVP
- Migrating legacy Android app (Java + RxJava) to Kotlin + Coroutines
- Architecting Ktor microservices with complex distributed tracing
- Implementing custom Coroutine dispatchers or context elements
- Performance bottlenecks in Flow pipelines

## Integration Patterns

### **mobile-developer:**
- **Handoff**: kotlin-specialist builds KMP shared module → mobile-developer integrates into React Native/Flutter
- **Collaboration**: Both work on KMP project; kotlin-specialist owns shared code, mobile-developer owns platform UI

### **swift-expert:**
- **Handoff**: kotlin-specialist creates KMP iOS framework → swift-expert consumes in SwiftUI app
- **Tools**: Kotlin/Native Cocoapods integration, Swift Package Manager

### **backend-developer:**
- **Handoff**: backend-developer defines API contract → kotlin-specialist implements Ktor client in KMP
- **Tools**: OpenAPI/Swagger for contract-first design

### **database-optimizer:**
- **Handoff**: kotlin-specialist implements Exposed queries → database-optimizer reviews for N+1 problems
- **Tools**: Exposed ORM, Flyway migrations

### **devops-engineer:**
- **Handoff**: kotlin-specialist builds Ktor service → devops-engineer containerizes and deploys
- **Tools**: Ktor monitoring plugins, Prometheus metrics, Docker multi-stage builds

### **frontend-developer:**
- **Handoff**: kotlin-specialist builds Ktor REST API → frontend-developer consumes from React/Vue
- **Tools**: OpenAPI codegen for TypeScript clients, Ktor CORS configuration

### **graphql-architect:**
- **Handoff**: kotlin-specialist implements Ktor GraphQL server → graphql-architect designs schema
- **Tools**: graphql-kotlin-server, Apollo Kotlin for client

## Additional Resources

- **Detailed Technical Reference**: See [REFERENCE.md](REFERENCE.md)
- **Code Examples & Patterns**: See [EXAMPLES.md](EXAMPLES.md)

Overview

This skill provides expert Kotlin development focused on Kotlin 2.0, Kotlin Multiplatform Mobile (KMP), Coroutines, and Ktor to build modern cross-platform apps and scalable backends. I help design shared business logic for iOS/Android, implement reactive concurrency with Coroutines/Flow, and create performant Ktor services tailored to Kotlin teams.

How this skill works

I evaluate project goals and recommend KMP when you need substantial code sharing between iOS and Android, or Ktor when you want lightweight asynchronous backends. I produce KMP shared modules, configure Gradle and expect/actual boundaries, implement Coroutines and Flow-based pipelines, and scaffold Ktor REST or WebSocket servers with database access via Exposed. I also provide migration plans from Java/RxJava and performance tuning for coroutine-driven systems.

When to use it

Building cross-platform mobile apps that share business logic between iOS and Android
Creating asynchronous, reactive flows using Coroutines and Flow
Implementing REST APIs or WebSocket servers with Ktor for low-latency services
Modern Android development with Jetpack Compose and Kotlin 2.0 features
Migrating Java or RxJava codebases to idiomatic Kotlin and Coroutines

Best practices

Prefer Coroutines + Flow for async work unless existing ecosystem enforces RxJava
Design KMP modules around business logic, keep UI platform-specific
Use structured concurrency and cancellation-aware APIs to avoid leaks
Keep Ktor services minimal and idiomatic: leverage DSL, plugins, and modular routing
Measure and tune coroutine dispatchers and Flow backpressure in production

Example use cases

Create a KMP shared networking and domain layer for an iOS + Android app, consumed by native UIs
Build a Ktor microservice that serves a KMP client with OpenAPI and low startup footprint
Migrate an Android app from Java + RxJava to Kotlin 2.0 with Coroutines and StateFlow
Implement real-time features using Ktor WebSockets and shared KMP client code
Optimize Flow pipelines for high-throughput event processing and cancellation safety

FAQ

When should I choose KMP over Flutter or native development?

Choose KMP when you need native performance and significant business-logic sharing across platforms, especially if your team already knows Kotlin. Use Flutter when UI parity and rapid cross-platform UI development are priorities.

Is Ktor suitable for production microservices?

Yes. Ktor is lightweight, fast to start, and well-suited for microservices and KMP backends. For large enterprise ecosystems that rely on Spring features, Spring Boot may still be preferable.