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
Code Examples & Patterns: See EXAMPLES.md

kotlin-specialist