Claude Code Kotlin: Idiomatischen Code generieren, Java migrieren, Coroutinen debuggen

Kotlin hat sich in den letzten Jahren zur bevorzugten JVM-Sprache entwickelt — nicht nur für Android, sondern auch für Backend-Systeme mit Ktor oder Spring. Die Sprache ist ausdrucksstärker als Java, ohne die JVM-Interoperabilität aufzugeben. Aber genau diese Ausdrucksstärke hat eine Kehrseite: Kotlin-Code kann funktionieren, ohne idiomatisch zu sein. Ein direktes Java-Port ist syntaktisch gültig, aber es verschenkt alles, was Kotlin besser macht als Java.

Claude Code Kotlin bedeutet: idiomatischen Kotlin-Code generieren, Java-Codebasen migrieren, Coroutine-Fehler systematisch debuggen und Null-Safety-Konzepte direkt im Kontext des eigenen Projekts verstehen — ohne Wikipedia-Artikel, ohne Stack Overflow, ohne Tab-Wechsel.

1. Was ist Kotlin — und warum ist es mehr als „besseres Java"

Kotlin läuft auf der JVM und ist vollständig interoperabel mit Java: jede Java-Bibliothek kann ohne Adapter verwendet werden, Java-Code kann Kotlin-Code aufrufen und umgekehrt. Das macht Kotlin zur idealen Migrationssprache — du kannst eine Codebasis Datei für Datei umstellen, ohne das Projekt einzufrieren.

Darüber hinaus läuft Kotlin als Kotlin Multiplatform auch nativ auf iOS, im Browser (via Kotlin/JS) und als native Binaries (Kotlin/Native). Der Code zwischen Plattformen kann geteilt werden — Business-Logik einmal schreiben, überall verwenden.

Die drei wichtigsten technischen Unterschiede zu Java:

• Null-Safety im Typsystem: In Kotlin ist null kein gültiger Wert für einen normalen Typ. Nur Nullable-Typen (String?) dürfen null sein. NullPointerExceptions werden damit vom Runtime- zum Compile-Time-Problem — der Compiler erzwingt die Behandlung.
• Coroutines statt Threads: Asynchroner Code ohne Callback-Hölle und ohne den Overhead von OS-Threads. Coroutines sind leichtgewichtige, suspendierbare Funktionen — du kannst Hunderttausende gleichzeitig laufen lassen.
• Ausdrucksstärke: Data Classes, Sealed Classes, Extension Functions, Scope Functions — Konzepte, die in Java viele Zeilen brauchen, werden in Kotlin auf eine Zeile komprimiert.

2. Grundlagen: val, var, data classes, sealed classes, when

Der erste Kotlin-Unterschied, der Java-Entwicklern auffällt: val und var. val ist immutable (wie final in Java), var ist mutable. Die Empfehlung: immer val, außer mutability ist explizit nötig.

// Kotlin-Grundlagen
val name: String = "Daniel"         // immutable, Typ explizit
var counter = 0                      // mutable, Typ inferiert

// Data Class: equals, hashCode, toString, copy gratis
data class User(
    val id: Long,
    val name: String,
    val email: String
)

val user = User(1L, "Daniel", "d@example.com")
val updated = user.copy(email = "new@example.com")  // strukturelle Kopie

Sealed Classes sind enums auf Steroiden: jede Subklasse kann eigene Properties haben, und der Compiler weiß, dass die Liste vollständig ist. Das macht when-Ausdrücke exhaustive — du bekommst einen Compile-Fehler, wenn du einen Fall vergisst.

// Sealed Class für UI-Zustand
sealed class UiState {
    object Loading : UiState()
    data class Success(val data: List<User>) : UiState()
    data class Error(val message: String, val code: Int) : UiState()
}

// when als Ausdruck (kein return nötig)
fun render(state: UiState): String = when (state) {
    is UiState.Loading  -> "Lädt..."
    is UiState.Success  -> "${state.data.size} Einträge geladen"
    is UiState.Error    -> "Fehler ${state.code}: ${state.message}"
    // Kein else nötig — Compiler prüft Vollständigkeit
}

3. Null-Safety: ?, ?:, !! und die Scope Functions

Null-Safety ist das Feature, das Kotlin-Neulinge am häufigsten falsch verstehen — und das am stärksten zur Codequalität beiträgt, wenn es richtig eingesetzt wird.

Grundregel: Der Typ String kann niemals null sein. String? darf null sein. Der Compiler erzwingt, dass du null behandelst, bevor du auf den Wert zugreifst.

// Null-Safety Operatoren
val name: String? = getUserName()   // kann null sein

// Safe-Call: gibt null zurück wenn name null ist
val length = name?.length           // Int?

// Elvis-Operator: Fallback wenn null
val displayName = name ?: "Anonym"  // String, nie null

// Not-null assertion: wirft NPE wenn null — nur wenn du 100% sicher bist
val forced = name!!.length          // gefährlich, vermeiden

// let: Code nur ausführen wenn nicht null
name?.let { n ->
    println("Name hat ${n.length} Zeichen")
}

Die Scope Functions (let, also, apply, run) sind das, was Kotlin-Code elegant macht. Jede hat eine spezifische Semantik:

// apply: Objekt konfigurieren, Objekt zurückgeben
val builder = StringBuilder().apply {
    append("Hallo")
    append(" Welt")
}

// also: Seiteneffekte, Objekt weiterreichen
val user = createUser().also { u ->
    logger.info("User erstellt: ${u.id}")
}

// run: Block ausführen, Ergebnis zurückgeben
val result = user.run {
    "$name <$email>"
}

// let: Transformation mit Null-Check kombinieren
val message = name?.let { "Hallo, $it!" } ?: "Hallo, Gast!"

4. Coroutines: suspend, launch/async, structured concurrency, Flow

Coroutines sind das Herzstück von modernem Kotlin. Statt Callbacks oder RxJava-Streams schreibst du asynchronen Code, der wie synchroner Code aussieht — aber nicht blockiert.

// suspend-Funktion: kann angehalten werden ohne den Thread zu blockieren
suspend fun fetchUser(id: Long): User {
    return api.getUser(id)  // wartet, aber blockiert keinen Thread
}

// launch: Coroutine starten, kein Rückgabewert
viewModelScope.launch {
    val user = fetchUser(42L)   // suspend-Aufruf, sieht synchron aus
    _uiState.value = UiState.Success(user)
}

// async/await: parallele Ausführung mit Ergebnis
viewModelScope.launch {
    val userDeferred = async { fetchUser(42L) }
    val postsDeferred = async { fetchPosts(42L) }

    val user = userDeferred.await()
    val posts = postsDeferred.await()
    // Beide Requests laufen parallel
}

Structured Concurrency bedeutet: Coroutines haben einen Scope. Wenn der Scope endet (z.B. weil ein ViewModel aufgeräumt wird), werden alle Coroutines in diesem Scope automatisch abgebrochen. Kein Memory-Leak, kein hängender Background-Task.

Flow ist Kotlins Antwort auf reaktive Streams — eine Coroutine, die mehrere Werte über die Zeit emittiert:

// Flow: asynchroner Datenstrom
fun userFlow(id: Long): Flow<User> = flow {
    while (true) {
        emit(fetchUser(id))
        delay(30_000)  // alle 30 Sekunden aktualisieren
    }
}

// Sammeln im ViewModel
viewModelScope.launch {
    userFlow(42L)
        .catch { e -> _error.value = e.message }
        .collect { user -> _uiState.value = UiState.Success(user) }
}

5. Android und Backend: Ktor vs. Spring mit Kotlin

Kotlin ist die offizielle Sprache für Android-Entwicklung. Alle modernen Android-APIs (Jetpack, Room, WorkManager) sind auf Kotlin und Coroutines ausgelegt. Wer noch in Java entwickelt, verliert Zeit und Ausdrucksstärke.

Auf dem Backend gibt es zwei dominante Optionen:

Ktor ist das Kotlin-native Framework von JetBrains: leichtgewichtig, asynchron von Grund auf, und mit einer DSL-basierten Konfiguration, die typisch für Kotlin ist. Ideal für Microservices und APIs.

// Ktor: minimaler HTTP-Server
fun Application.module() {
    routing {
        get("/users/{id}") {
            val id = call.parameters["id"]?.toLong()
                ?: return@get call.respond(HttpStatusCode.BadRequest)
            val user = userService.getUser(id)
            call.respond(user)
        }
    }
}

Spring Boot mit Kotlin ist die Enterprise-Option: bewährt, umfangreich dokumentiert, mit riesigem Ökosystem. Spring hat Kotlin-Support eingebaut — Coroutines funktionieren direkt in Spring MVC und Spring WebFlux.

// Spring Boot mit Kotlin und Coroutines
@RestController
class UserController(private val service: UserService) {

    @GetMapping("/users/{id}")
    suspend fun getUser(@PathVariable id: Long): User =
        service.findById(id) ?: throw ResponseStatusException(HttpStatus.NOT_FOUND)
}

6. Claude Code Kotlin: Vier konkrete Anwendungsfälle

Idiomatischen Kotlin-Code generieren

Das häufigste Problem: Code der funktioniert, aber nicht Kotlin-typisch ist. Java-Patterns, die in Kotlin anders gelöst werden.

claude "Diese Funktion funktioniert, aber sie sieht nach Java aus.
Schreib sie idiomatisch in Kotlin um, mit Null-Safety und Scope Functions:

fun processUser(user: User?): String {
    if (user == null) return 'Unbekannt'
    if (user.name == null) return 'Kein Name'
    return user.name.trim().uppercase()
}"

Claude Code liest den Kontext, versteht die Semantik und schreibt: user?.name?.trim()?.uppercase() ?: "Unbekannt" — eine Zeile, vollständig null-safe, Kotlin-idiomatisch.

Java zu Kotlin migrieren

Die mechanische Konvertierung macht IntelliJ bereits. Was Claude Code dazu beiträgt: die Konvertierung verbessern, nicht nur übersetzen.

claude "Diese Java-Klasse wurde automatisch nach Kotlin konvertiert.
Verbessere sie: data class verwenden wo sinnvoll, Null-Safety korrekt,
Builder-Pattern durch named parameters ersetzen, Scope Functions einsetzen."

Claude Code liest die konvertierte Datei, identifiziert alle Stellen, die noch Java-Denkweise zeigen, und schreibt sie Kotlin-typisch um. Was IntelliJ konvertiert, macht Claude Code idiomatisch.

Coroutine-Fehler debuggen

Coroutine-Stack-Traces sind notorisch schwer zu lesen: sie zeigen den internen Mechanismus, nicht den eigentlichen Fehler. Claude Code übersetzt das in verständliche Diagnosen.

claude "Dieser Coroutine-Stack-Trace taucht im Produktionsbetrieb auf.
Was ist der eigentliche Fehler und wo liegt er?

kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled
    at kotlinx.coroutines.JobSupport.cancel(JobSupport.kt:1578)
    at com.example.UserViewModel.onCleared(UserViewModel.kt:45)"

Null-Safety erklären und anwenden

Für Teams, die von Java kommen, ist Null-Safety der größte konzeptuelle Sprung. Claude Code erklärt es nicht abstrakt, sondern am eigenen Code:

claude "Erkläre, warum der Compiler hier einen Fehler wirft, und
zeige die drei möglichen Lösungen mit Vor- und Nachteilen:

val user: User? = getUser()
println(user.name)   // Compiler-Fehler"

Die Antwort erklärt das Typsystem, zeigt user?.name, user!!.name und user?.name ?: "default" — mit dem Hinweis, wann welche Variante semantisch korrekt ist. Nicht als generisches Tutorial, sondern bezogen auf den konkreten Code im Projekt.

Claude Code macht Kotlin-Entwicklung schneller — aber vor allem macht es sie besser. Der Unterschied zwischen Code der kompiliert und Code der idiomatisch Kotlin nutzt, ist in einer gut geführten Claude-Code-Session sichtbar: Sealed Classes statt String-Konstanten, Scope Functions statt verschachtelter Null-Checks, Coroutines statt Thread-Pools. Das ist nicht nur Stil — es ist weniger Bugs, weniger Boilerplate, mehr Wartbarkeit.

• Claude Code Debugging — Stack Traces analysieren und Root-Cause finden
• Claude Code für Unternehmen — Deployment und Team-Workflows