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" belowBackend 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