메뉴
Kotlin 2.0 Multiplatform Enterprise Development with KMP, Coroutines, Compose Multiplatform, and Context7 MCP integration. Advanced patterns for mobile, backend, and cross-platform development.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-lang-kotlin명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Enterprise database architecture specialist with PostgreSQL 17, MySQL 8.4 LTS, MongoDB 8.0, Redis 7.4 expertise. Master connection pooling, query optimization, caching strategies, and database DevOps automation. Build scalable, resilient database systems with comprehensive monitoring and disaster recovery.
Enterprise Frontend Development with AI-powered modern architecture, Context7 integration, and intelligent component orchestration for scalable user interfaces
Enterprise-grade security expertise with production-ready patterns for OWASP Top 10 2021, zero-trust architecture, threat modeling (STRIDE, PASTA), secure SDLC, DevSecOps automation, cloud security, cryptography, identity & access management, and compliance frameworks (SOC 2, ISO 27001, GDPR, CCPA).
SOC 직업 분류 기준
SKILL.md 표시 중
| name | moai-lang-kotlin |
| version | 4.0.0 |
| created | 2025-10-22T00:00:00.000Z |
| updated | 2025-11-13T00:00:00.000Z |
| status | stable |
| description | Kotlin 2.0 Multiplatform Enterprise Development with KMP, Coroutines, Compose Multiplatform, and Context7 MCP integration. Advanced patterns for mobile, backend, and cross-platform development. |
| keywords | ["kotlin","kmp","coroutines","compose","android","multiplatform","enterprise","context7"] |
| allowed-tools | ["Read","Bash","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"] |
Kotlin 2.0 Multiplatform enterprise development with advanced async patterns, KMP architecture, and Compose Multiplatform UI. This skill provides patterns for mobile, backend, and cross-platform development with full Context7 MCP integration for real-time documentation access.
Automatic activation:
Manual invocation:
| Component | Version | Purpose | Status |
|---|---|---|---|
| Kotlin | 2.0.20 | Core language | Current |
| Coroutines | 1.8.0 | Async programming | Current |
| Compose Multiplatform | 1.6.10 | UI framework | Current |
| Serialization | 1.7.1 | JSON/data serialization | Current |
| Ktor | 2.3.12 | HTTP client/server | Current |
| Android Gradle Plugin | 8.5.0 | Android build | Current |
Kotlin's null safety is a game-changer for enterprise development:
// Smart null handling
val name: String? = "John"
val length = name?.length ?: 0 // Safe navigation + Elvis operator
// Type-safe IDs with inline classes
@JvmInline
value class UserId(val value: String)
// Sealed hierarchies for domain modeling
sealed class Result<T> {
data class Success<T>(val data: T) : Result<T>()
data class Error(val exception: Throwable) : Result<Nothing>()
}
Key Benefits:
NullPointerException at compile timeEnterprise async patterns with built-in safety:
// Structured concurrency scope
coroutineScope {
val result1 = async { fetchData("API1") }
val result2 = async { fetchData("API2") }
awaitAll(result1, result2)
} // All coroutines cancelled if scope exits
// Context switching
withContext(Dispatchers.IO) {
val data = blockingIoCall() // Safe switching
}
// Error isolation with supervisor scope
supervisorScope {
launch { riskyOperation1() } // Failure doesn't affect others
launch { riskyOperation2() }
}
Key Benefits:
Powerful language extension without inheritance:
// Domain-specific languages (DSLs)
fun html(block: HtmlBuilder.() -> Unit): String {
val builder = HtmlBuilder()
builder.block()
return builder.build()
}
// Usage
val page = html {
h1("Welcome")
p("This is a paragraph")
}
// See examples.md for complete DSL patterns
kmp-enterprise-app/
├── shared/
│ ├── src/
│ │ ├── commonMain/kotlin/
│ │ │ ├── domain/ # Business logic
│ │ │ ├── data/ # Data layer
│ │ │ └── presentation/ # State management
│ │ ├── androidMain/kotlin/
│ │ ├── iosMain/kotlin/
│ │ └── commonTest/kotlin/
├── androidApp/
├── iosApp/
└── webApp/
// commonMain: Define interface
expect class PlatformDatabase {
suspend fun saveData(data: String): Result<Unit>
}
// androidMain: Android implementation
actual class PlatformDatabase {
actual suspend fun saveData(data: String) = try {
room.insert(data)
Result.success(Unit)
} catch (e: Exception) {
Result.failure(e)
}
}
// iosMain: iOS implementation
actual class PlatformDatabase {
actual suspend fun saveData(data: String) = try {
coreData.save(data)
Result.success(Unit)
} catch (e: Exception) {
Result.failure(e)
}
}
Key Pattern:
commonMain// Create cold flow (lazy)
fun getUsersFlow(): Flow<User> = flow {
while (true) {
val users = repository.fetchUsers()
emit(users)
delay(5000) // Refresh every 5 seconds
}
}
// Compose flows
getUsersFlow()
.map { it.copy(name = it.name.uppercase()) }
.filter { it.isActive }
.distinctUntilChanged()
.collect { updateUI(it) }
class CounterViewModel {
private val _count = MutableStateFlow(0)
val count: StateFlow<Int> = _count.asStateFlow()
fun increment() { _count.value++ }
fun decrement() { _count.value-- }
}
// Observe state changes
viewModel.count.collect { count ->
updateUI("Count: $count")
}
@Composable
fun UserListScreen(users: List<User>) {
Column(modifier = Modifier.fillMaxSize()) {
Text("Users", style = MaterialTheme.typography.headlineLarge)
LazyColumn {
items(users) { user ->
UserCard(user)
}
}
}
}
@Composable
fun UserCard(user: User) {
Card(modifier = Modifier.fillMaxWidth().padding(8.dp)) {
Column(modifier = Modifier.padding(16.dp)) {
Text(user.name, style = MaterialTheme.typography.titleMedium)
Text(user.email, color = Color.Gray)
}
}
}
Key Concepts:
val appModule = module {
single { HttpClient() }
single { UserRepository(get()) }
viewModel { UserListViewModel(get()) }
}
// Usage
val userService: UserService = get() // Injected automatically
// Result wrapper for safe operations
suspend fun fetchData(): Result<String> = try {
Result.success(apiCall())
} catch (e: Exception) {
Result.failure(e)
}
// Chain operations safely
fetchData()
.onSuccess { data -> updateUI(data) }
.onFailure { error -> showError(error) }
@Test
fun testAsync() = runTest {
val result = someAsyncFunction()
assertEquals("expected", result)
}
@Test
fun testWithMock() {
val repo = mockk<Repository>()
coEvery { repo.fetch("1") } returns "data"
// Verify behavior
coVerify { repo.fetch("1") }
}
This skill integrates with Context7 for real-time access to official documentation:
/kotlin/kotlin/kotlin/kotlinx.coroutines/kotlin/kotlin.multiplatform/jetbrains/compose-multiplatform/ktor/ktor/kotlin/kotlinx.serialization// Get latest coroutine patterns
val docs = mcp__context7__get-library-docs(
context7CompatibleLibraryID = "/kotlin/kotlinx.coroutines"
)
Use Sequence for lazy evaluation:
(1..1_000_000).asSequence()
.filter { it % 2 == 0 }
.map { it * 2 }
.toList() // Only processes what's needed
Inline classes for zero-overhead:
@JvmInline
value class UserId(val value: String) // No allocation at runtime
Primitive arrays instead of boxed:
val intArray = IntArray(1000) // More efficient than Array<Int>
Tail recursion:
tailrec fun factorial(n: Int, acc: Int = 1): Int =
if (n <= 1) acc else factorial(n - 1, n * acc)
Coroutine pooling (automatic with structured concurrency)
// GOOD
coroutineScope {
val result = async { fetchData() }
}
// AVOID
GlobalScope.launch { fetchData() } // Never use
// GOOD
val user = repository.findUser(id)
?.let { updateUI(it) }
?: showNotFound()
// AVOID
val user = repository.findUser(id)!! // Unsafe
// GOOD
File("data.txt").bufferedReader().use { reader ->
reader.readLines()
} // Auto-closes
// GOOD
try {
// Use resource
} finally {
resource.close()
}
data class SecureUserInput(val email: String) {
init {
require(email.contains("@")) { "Invalid email" }
require(email.length <= 254) { "Email too long" }
}
}
expect class SecureStorage {
suspend fun store(key: String, value: String)
suspend fun retrieve(key: String): String?
}
// Certificate pinning
val client = HttpClient {
install(Auth) {
bearer {
loadTokens { getBearerTokens() }
}
}
}
| Category | Target | Tools |
|---|---|---|
| Unit Tests | 80% | Kotest, MockK, runTest |
| Integration Tests | 15% | Kotest, testcontainers |
| UI Tests | 5% | Compose Test |
moai-foundation-trust (TRUST 5 quality gates)moai-foundation-security (Enterprise security)moai-foundation-testing (Testing strategies)moai-cc-mcp-integration (MCP integration)moai-essentials-debug (Debugging)examples.md (29 examples covering all patterns)reference.md (installation, commands, troubleshooting)Last updated: 2025-11-13