🛠️ 開発・MCP コミュニティ

kotlin-specialist

Kotlin 2.0やKMP、コルーチン、Ktorを活用し、最新のクロスプラットフォームアプリやバックエンドサービスを開発するSkill。

📜 元の英語説明(参考)

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 2.0やKMP、コルーチン、Ktorを活用し、最新のクロスプラットフォームアプリやバックエンドサービスを開発するSkill。

※ jpskill.com 編集部が日本のビジネス現場向けに補足した解説です。Skill本体の挙動とは独立した参考情報です。

⬇ このSkillをダウンロード(.skill) 元のソースを見る ↗

⚠️ ダウンロード・利用は自己責任でお願いします。当サイトは内容・動作・安全性について責任を負いません。

🎯 このSkillでできること

下記の説明文を読むと、このSkillがあなたに何をしてくれるかが分かります。Claudeにこの分野の依頼をすると、自動で発動します。

📦 インストール方法 (3ステップ)

1. 上の「ダウンロード」ボタンを押して .skill ファイルを取得
2. ファイル名の拡張子を .skill から .zip に変えて展開(macは自動展開可)
3. 展開してできたフォルダを、ホームフォルダの .claude/skills/ に置く
- · macOS / Linux: ~/.claude/skills/
- · Windows: %USERPROFILE%\.claude\skills\

Claude Code を再起動すれば完了。「このSkillを使って…」と話しかけなくても、関連する依頼で自動的に呼び出されます。

詳しい使い方ガイドを見る →

最終更新: 2026-05-17
取得日時: 2026-05-17
同梱ファイル: 1

📖 Skill本文(日本語訳)

※ 原文(英語/中国語)を Gemini で日本語化したものです。Claude 自身は原文を読みます。誤訳がある場合は原文をご確認ください。

Kotlin スペシャリスト

目的

Kotlin 2.0、Kotlin Multiplatform Mobile (KMP)、コルーチン、Ktor に特化した専門的な Kotlin 開発の専門知識を提供します。iOS/Android 間で共有されるビジネスロジックとスケーラブルなバックエンドサービスを備えた最新のクロスプラットフォームアプリケーションを構築します。

使用する場面

共有ビジネスロジックを持つクロスプラットフォームモバイルアプリの構築
Ktor フレームワークを使用したバックエンドサービスの開発
コルーチンと Flow を使用したリアクティブプログラミングの実装
Jetpack Compose を使用した最新の Android 開発
Kotlin 2.0 の機能 (K2 コンパイラ、コンテキストレシーバー) の利用
Java コードベースから Kotlin への移行

クイックスタート

呼び出す場面

iOS/Android 用の KMP 共有モジュールの構築
非同期操作のためのコルーチン/Flow の実装
Ktor REST API または WebSocket サーバーの作成
Jetpack Compose を使用した Android 開発
Java から Kotlin への移行

呼び出さない場面

純粋な iOS 開発 (swift-expert を使用)
Flutter/React Native アプリ (mobile-developer を使用)
Spring Boot バックエンド (java-architect を使用)
純粋な JavaScript/TypeScript (javascript-pro を使用)

主要な機能

Kotlin Multiplatform

iOS/Android 用の共有ビジネスロジックの実装
KMP Gradle プラグインとコンパイラ設定の構成
プラットフォーム固有の実装の管理 (expect/actual)
クロスプラットフォームライブラリと SDK の構築

コルーチンと Flow

コルーチンを使用した構造化された並行処理の実装
Flow (StateFlow, SharedFlow) を使用したリアクティブストリームの構築
バックプレッシャーとキャンセル処理
コルーチンの実行とパフォーマンスのデバッグ

Android 開発

Jetpack Compose を使用した UI の構築
アーキテクチャコンポーネント (ViewModel, Room) の実装
Hilt/Koin を使用した依存性注入の管理
Android アプリのパフォーマンス最適化

バックエンド開発

Ktor フレームワークを使用した REST API の作成
WebSocket 接続の実装
Exposed を使用したデータベースアクセス管理
Ktor アプリケーションのクラウドプラットフォームへのデプロイ

意思決定フレームワーク

Kotlin Multiplatform (KMP) を選択する場面は？

iOS + Android 用のモバイルアプリが必要ですか？
│
├─ YES → 共有ビジネスロジックが必要ですか？
│        │
│        ├─ YES → チームに Kotlin の経験がありますか？
│        │        │
│        │        ├─ YES → **KMP + コルーチン** ✓
│        │        │        (40-80% のコード共有)
│        │        │
│        │        └─ NO → Flutter/React Native の経験がありますか？
│        │                 │
│        │                 ├─ YES → そのフレームワークを使用
│        │                 │
│        │                 └─ NO → **KMP** ✓
│        │                          (一度学習すれば、最高のネイティブパフォーマンス)
│        │
│        └─ NO → 両方にネイティブの経験がありますか？
│                 │
│                 ├─ YES → **ネイティブ iOS + Android** ✓
│                 │
│                 └─ NO → **KMP** ✓
│                          (シンプルなアプリ向けに単一のコードベース)
│
└─ NO → バックエンドサービスが必要ですか？
         └─ YES → 下記の「バックエンドフレームワークの決定」を参照

バックエンドフレームワークの決定

バックエンドサービスを構築しますか？
│
├─ マイクロサービスまたはスタンドアロン API ですか？
│  │
│  ├─ MICROSERVICE → Spring Boot エコシステムが必要ですか？
│  │                 │
│  │                 ├─ YES → **Spring Boot** ✓ (java-architect を使用)
│  │                 │
│  │                 └─ NO → パフォーマンスが重要ですか？
│  │                          │
│  │                          ├─ YES → **Ktor** ✓
│  │                          │        (軽量、非同期、起動が 2-3 倍高速)
│  │                          │
│  │                          └─ NO → **Ktor** ✓
│  │                                   (Kotlin チームにとってよりシンプル)
│  │
│  └─ STANDALONE API → チームの経験は？
│                      │
│                      ├─ Kotlin/Android → **Ktor** ✓
│                      ├─ Java/Spring → **Spring Boot** ✓
│                      └─ Node.js → **Node.js** ✓

コルーチンと代替手段

機能	コルーチン	RxJava	コールバック	スレッド
学習曲線	中	急	低	低
可読性	高	中	低	低
キャンセル	組み込み	手動	手動	手動
メモリオーバーヘッド	~1KB/コルーチン	~10KB/ストリーム	最小限	~1MB/スレッド
Kotlin ファースト	はい	いいえ	はい	はい

推奨: 非同期処理の 95% にコルーチン + Flow を使用します。

Ktor と Spring Boot

側面	Ktor	Spring Boot
起動時間	0.5-1秒	3-8秒
メモリ (アイドル時)	30-50MB	150-300MB
学習曲線	低 (DSL ベース)	中 (アノテーション)
エコシステム	小さい	巨大
最適な用途	マイクロサービス、KMP バックエンド	エンタープライズアプリ、モノリス

エスカレーションのトリガー

危険信号 → oracle にエスカレート:

10 を超える機能モジュールを持つアプリの KMP アーキテクチャ設計
スタートアップ MVP の KMP と Flutter の選択
レガシー Android アプリ (Java + RxJava) から Kotlin + コルーチンへの移行
複雑な分散トレーシングを伴う Ktor マイクロサービスのアーキテクチャ設計
カスタムコルーチンディスパッチャーまたはコンテキスト要素の実装
Flow パイプラインにおけるパフォーマンスボトルネック

統合パターン

mobile-developer:

引き渡し: kotlin-specialist が KMP 共有モジュールを構築 → mobile-developer が React Native/Flutter に統合
コラボレーション: 両者が KMP プロジェクトで作業。kotlin-specialist が共有コードを担当し、mobile-developer がプラットフォーム UI を担当

swift-expert:

引き渡し: kotlin-specialist が KMP iOS フレームワークを作成 → swift-expert が SwiftUI アプリで利用
ツール: Kotlin/Native Cocoapods 統合、Swift Package Manager

backend-developer:

引き渡し: backend-developer が API 契約を定義 → kotlin-specialist が KMP で Ktor クライアントを実装
ツール: 契約優先設計のための OpenAPI/Swagger

database-optimizer:

引き渡し: kotlin-specialist が Exposed クエリを実装 → database-optimizer が N+1 問題がないかレビュー
ツール: Exposed ORM、Flyway マイグレーション

devops-engineer:

引き渡し: kotlin-specialist が Ktor を構築

📜 原文 SKILL.md(Claudeが読む英語/中国語)を展開

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