Skip to main content Skills Marketplace Descubre y explora habilidades de IA creadas por la comunidad.
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Mostrar detalles del prompt Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/diegosouzapw/awesome-omni-skill --skill moai-lang-kotlinEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Descargar Zip Descargando... Más de este repositorio Token-efficient tracking for AI orchestration. CLI-first for status updates (~50 tokens), agent fallback for complex ops (~1KB). Use when: updating task status, querying blockers, creating progress files, validating phases.
AshAi extension guidelines for integrating AI capabilities with Ash Framework. Use when implementing vectorization/embeddings, exposing Ash actions as LLM tools, creating prompt-backed actions, or setting up MCP servers. Covers semantic search, LangChain integration, and structured outputs.
This skill should be used when solving hard questions, complex architectural problems, or debugging issues that benefit from GPT-5 Pro or GPT-5.1 thinking models with large file context. Use when standard Claude analysis needs deeper reasoning or extended context windows.
Ocupaciones relacionadas SOC
Basado en la clasificación ocupacional SOC
Explorador de archivos
2 archivos name moai-lang-kotlin description Kotlin 2.0+ development specialist covering Ktor, coroutines, Compose Multiplatform, and Kotlin-idiomatic patterns. Use when building Kotlin server apps, Android apps, or multiplatform projects. version 1.0.0 category language modularized false user-invocable false tags ["kotlin","ktor","coroutines","compose","android","multiplatform"] context7-libraries /ktorio/ktor, /jetbrains/compose-multiplatform, /jetbrains/exposed related-skills moai-lang-java, moai-lang-swift updated "2025-12-07T00:00:00.000Z" status active
Quick Reference (30 seconds)
Kotlin 2.0+ Expert - K2 compiler, coroutines, Ktor, Compose Multiplatform with Context7 integration.
Auto-Triggers: Kotlin files (.kt, .kts), Gradle Kotlin DSL (build.gradle.kts, settings.gradle.kts)
Core Capabilities:
Kotlin 2.0: K2 compiler, coroutines, Flow, sealed classes, value classes
Ktor 3.0: Async HTTP server/client, WebSocket, JWT authentication
Exposed 0.55: Kotlin SQL framework with coroutines support
Spring Boot (Kotlin): Kotlin-idiomatic Spring with WebFlux
Compose Multiplatform: Desktop, iOS, Web, Android UI
Testing: JUnit 5, MockK, Kotest, Turbine for Flow testing
Implementation Guide (5 minutes)
Kotlin 2.0 Features
Coroutines and Flow:
suspend fun fetchUserWithOrders (userId: Long ) val userDeferred = async { userRepository.findById(userId) }
val ordersDeferred = async { orderRepository.findByUserId(userId) }
UserWithOrders(userDeferred.await(), ordersDeferred.await())
}
fun observeUsers () while (true ) {
emit(userRepository.findLatest())
delay(1000 )
}
}.flowOn(Dispatchers.IO)
Sealed Classes and Value Classes:
sealed interface Result <out T > {
data class Success <T >(val data : T) : Result<T>
data class
Error
val
Nothing
data
object
Nothing
@JvmInline
class
UserId
val
Long
init
0
"UserId must be positive"
@JvmInline
class
Email
val
init
"@"
"Invalid email format"
Ktor 3.0 Server fun main () 8080 , host = "0.0.0.0" ) {
configureKoin()
configureSecurity()
configureRouting()
configureContentNegotiation()
}.start(wait = true )
}
fun Application.configureKoin () val appModule = module {
single<Database> { DatabaseFactory.create() }
single<UserRepository> { UserRepositoryImpl(get ()) }
single<UserService> { UserServiceImpl(get ()) }
}
fun Application.configureSecurity () "auth-jwt" ) {
realm = "User API"
verifier(JwtConfig.verifier)
validate { credential ->
if (credential.payload.audience.contains("api" ))
JWTPrincipal(credential.payload) else null
}
}
}
}
fun Application.configureContentNegotiation () true ; ignoreUnknownKeys = true })
}
}
Routing with Authentication:
fun Application.configureRouting () val userService by inject<UserService>()
routing {
route("/api/v1" ) {
post("/auth/register" ) {
val request = call.receive<CreateUserRequest>()
val user = userService.create(request)
call.respond(HttpStatusCode.Created, user.toDto())
}
authenticate("auth-jwt" ) {
route("/users" ) {
get {
val page = call.parameters["page" ]?.toIntOrNull() ?: 0
val size = call.parameters["size" ]?.toIntOrNull() ?: 20
call.respond(userService.findAll(page, size).map { it.toDto() })
}
get ("/{id}" ) {
val id = call.parameters["id" ]?.toLongOrNull()
?: return @get call.respond(HttpStatusCode.BadRequest)
userService.findById(id)?.let { call.respond(it.toDto()) }
?: call.respond(HttpStatusCode.NotFound)
}
}
}
}
}
}
Exposed SQL Framework object Users : LongIdTable("users" ) {
val name = varchar("name" , 100 )
val email = varchar("email" , 255 ).uniqueIndex()
val passwordHash = varchar("password_hash" , 255 )
val status = enumerationByName<UserStatus>("status" , 20 )
val createdAt = timestamp("created_at" ).defaultExpression(CurrentTimestamp())
}
class UserEntity (id: EntityID<Long >) : LongEntity(id) {
companion object : LongEntityClass<UserEntity>(Users)
var name by Users.name
var email by Users.email
var passwordHash by Users.passwordHash
var status by Users.status
var createdAt by Users.createdAt
fun toModel () Repository with Coroutines:
class UserRepositoryImpl (private val database: Database) : UserRepository {
override suspend fun findById (id: Long ) override suspend fun save (user: User ) private suspend fun <T> dbQuery (block: suspend () -> T )
Spring Boot with Kotlin @RestController
@RequestMapping("/api/users" )
class UserController (private val userService: UserService) {
@GetMapping
suspend fun listUsers (
@RequestParam(defaultValue = "0" ) page: Int ,
@RequestParam(defaultValue = "20" ) size: Int
) @GetMapping("/{id}" )
suspend fun getUser (@PathVariable id: Long ) @PostMapping
suspend fun createUser (@Valid @RequestBody request: CreateUserRequest ) val user = userService.create(request)
return ResponseEntity.created(URI.create("/api/users/${user.id} " )).body(user.toDto())
}
}
Advanced Patterns
Compose Multiplatform @Composable
fun UserListScreen (viewModel: UserListViewModel , onUserClick: (Long ) -> Unit ) val uiState by viewModel.uiState.collectAsState()
when (val state = uiState) {
is UiState.Loading -> LoadingIndicator()
is UiState.Success -> UserList(state.users, onUserClick)
is UiState.Error -> ErrorMessage(state.message, onRetry = viewModel::retry)
}
}
@Composable
fun UserCard (user: User , onClick: () -> Unit ) 4. dp)
) {
Row(modifier = Modifier.padding(16. dp)) {
AsyncImage(model = user.avatarUrl, contentDescription = user.name,
modifier = Modifier.size(48. dp).clip(CircleShape))
Spacer(Modifier.width(16. dp))
Column {
Text(user.name, style = MaterialTheme.typography.titleMedium)
Text(user.email, style = MaterialTheme.typography.bodySmall)
}
}
}
}
Testing with MockK class UserServiceTest {
private val userRepository = mockk<UserRepository>()
private val userService = UserService(userRepository)
@Test
fun `should fetch user concurrently`() val testUser = User(1L , "John" , "john@example.com" )
coEvery { userRepository.findById(1L ) } coAnswers { delay(100 ); testUser }
val result = userService.findById(1L )
assertThat(result).isEqualTo(testUser)
}
@Test
fun `should handle Flow emissions`() val users = listOf(User(1L , "John" , "john@example.com" ))
coEvery { userRepository.findAllAsFlow() } returns users.asFlow()
userService.streamUsers().toList().also { result ->
assertThat(result).hasSize(1 )
}
}
}
Gradle Build Configuration plugins {
kotlin("jvm" ) version "2.0.20"
kotlin("plugin.serialization" ) version "2.0.20"
id("io.ktor.plugin" ) version "3.0.0"
}
kotlin { jvmToolchain(21 ) }
dependencies {
implementation("io.ktor:ktor-server-core-jvm" )
implementation("io.ktor:ktor-server-netty-jvm" )
implementation("io.ktor:ktor-server-content-negotiation-jvm" )
implementation("io.ktor:ktor-server-auth-jwt-jvm" )
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0" )
implementation("org.jetbrains.exposed:exposed-core:0.55.0" )
implementation("org.jetbrains.exposed:exposed-dao:0.55.0" )
implementation("org.postgresql:postgresql:42.7.3" )
testImplementation("io.mockk:mockk:1.13.12" )
testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0" )
testImplementation("app.cash.turbine:turbine:1.1.0" )
}
Context7 Integration Library mappings for latest documentation:
/ktorio/ktor - Ktor 3.0 server/client documentation/jetbrains/exposed - Exposed SQL framework/JetBrains/kotlin - Kotlin 2.0 language reference/Kotlin/kotlinx.coroutines - Coroutines library/jetbrains/compose-multiplatform - Compose Multiplatform/arrow-kt/arrow - Arrow functional programming docs = await mcp__context7__get_library_docs(
context7CompatibleLibraryID="/ktorio/ktor" ,
topic="routing authentication jwt" ,
tokens=8000
)
When to Use Kotlin
Developing Android applications (official language)
Building modern server applications with Ktor
Preferring concise, expressive syntax
Building reactive services with coroutines and Flow
Creating multiplatform applications (iOS, Desktop, Web)
Full Java interoperability required
Consider Alternatives When:
Legacy Java codebase requiring minimal changes
Big data pipelines (prefer Scala with Spark)
Works Well With
moai-lang-java - Java interoperability and Spring Boot patternsmoai-domain-backend - REST API, GraphQL, microservices architecturemoai-domain-database - JPA, Exposed, R2DBC patternsmoai-quality-testing - JUnit 5, MockK, TestContainers integrationmoai-infra-docker - JVM container optimization
Troubleshooting K2 Compiler: Add kotlin.experimental.tryK2=true to gradle.properties; clear .gradle for rebuild
Coroutines: Avoid runBlocking in suspend contexts; use Dispatchers.IO for blocking operations
Ktor: Ensure ContentNegotiation installed; check JWT verifier configuration; verify routing hierarchy
Exposed: Ensure all DB operations in transaction; be aware of entity loading outside transaction
Advanced Documentation For comprehensive reference materials:
reference.md - Complete ecosystem, Context7 mappings, testing patterns, performanceexamples.md - Production-ready code examples, Ktor, Compose, Android patterns
Last Updated: 2025-12-07
Status: Production Ready (v1.0.0)
