Claude Skill

java-kotlin

Use when writing modern Java (17+) or Kotlin on the JVM. Covers records, sealed interfaces, pattern matching, coroutines, null safety, and JVM performance and memory tuning. Trigger on "migrate this off java 8 style", "convert this to kotlin coroutines", "jvm keeps running out of

LLM Mart · 0 points · 1 views 0 listing impressions 0 install-command copies
Download nimadorostkar-claude-skills-collection-skills_languages_java-kotlin-1691932.zip · 2 KB

Install

skills CLI npx skills add https://github.com/nimadorostkar/Claude-Skills-collection/tree/main/skills/languages/java-kotlin
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install nimadorostkar-claude-skills-collection@llmmart
Git git clone https://github.com/nimadorostkar/Claude-Skills-collection.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole nimadorostkar/claude-skills-collection collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Java and Kotlin

Purpose

Write JVM code that uses the modern language surface — records, sealed types, pattern matching, coroutines — instead of the 2010-era idioms most JVM codebases are still carrying.

When to Use

  • Writing or reviewing Java 17+ or Kotlin.
  • Migrating a codebase off Java 8 idioms.
  • Designing domain models with records and sealed interfaces.
  • Introducing coroutines to replace callback or thread-pool code.
  • Diagnosing JVM memory, GC, or startup problems.

Capabilities

  • Java: records, sealed interfaces, pattern matching for switch, virtual threads, Optional discipline.
  • Kotlin: coroutines, structured concurrency, flows, null safety, delegation, DSL builders.
  • Java/Kotlin interop, including platform-type null hazards.
  • Build configuration for Gradle (Kotlin DSL) and Maven.
  • JVM tuning: heap sizing, GC selection, JFR profiling.

Inputs

  • Source module, build file, and target JVM version.
  • Whether the code is a library (binary compatibility matters) or an application.

Outputs

  • Modern, immutable-by-default domain types.
  • Concurrency that is structured and cancellable.
  • Build configuration pinned to a specific toolchain.

Workflow

  1. Model — Domain values as records (Java) or data classes (Kotlin). Variants as sealed interfaces.
  2. Match exhaustively — Use pattern-matching switch / when so a new variant becomes a compile error.
  3. Structure concurrency — Virtual threads (Java 21+) or coroutine scopes tied to a lifecycle.
  4. Guard nulls at the interop line — Every value crossing from Java into Kotlin is a platform type; annotate or validate it.
  5. Gate — Compile with warnings as errors; run SpotBugs/detekt and the test suite.

Best Practices

  • Never return null from a public API. Return Optional, an empty collection, or a sealed "absent" variant.
  • Records are for data, not for behavior with hidden state. Keep them free of mutable references.
  • In Kotlin, !! is a defect marker. If you cannot remove it, the type is lying.
  • Never launch a coroutine in GlobalScope. It has no cancellation owner.
  • Prefer runCatching only in application boundaries; libraries throw typed exceptions.
  • Pin the toolchain in the build file so the JVM version is not an environment variable.

Examples

Sealed model with exhaustive matching (Java 21):

sealed interface Payment permits Card, Transfer, Wallet {}

record Card(String last4, YearMonth expiry) implements Payment {}
record Transfer(String iban) implements Payment {}
record Wallet(String provider, String token) implements Payment {}

static String describe(Payment payment) {
    return switch (payment) {
        case Card c      -> "Card ending %s".formatted(c.last4());
        case Transfer t  -> "Transfer to %s".formatted(t.iban());
        case Wallet w    -> "%s wallet".formatted(w.provider());
    };
}

Structured concurrency in Kotlin:

suspend fun loadDashboard(userId: String): Dashboard = coroutineScope {
    val profile = async { userService.profile(userId) }
    val orders  = async { orderService.recent(userId, limit = 10) }
    Dashboard(profile.await(), orders.await())
}

Notes

  • Virtual threads (Java 21) remove most reasons to use a reactive framework for I/O-bound work. They do not help CPU-bound work.
  • coroutineScope propagates cancellation to children and rethrows the first failure; supervisorScope isolates failures. Choose deliberately.
  • Kotlin's Flow is cold. Collecting it twice runs the producer twice — a common source of duplicated API calls.
Files (claude-skills-collection)
  • SKILL.md 4.1 KB
    ---
    name: java-kotlin
    description: Use when writing modern Java (17+) or Kotlin on the JVM. Covers records, sealed interfaces, pattern matching, coroutines, null safety, and JVM performance and memory tuning. Trigger on "migrate this off java 8 style", "convert this to kotlin coroutines", "jvm keeps running out of memory", "gc pauses are killing latency". Do not use for Spring wiring, transactions, or JPA — see the spring-boot skill.
    metadata:
      category: languages
      version: 1.0.0
      tags: [java, kotlin, jvm, coroutines, records]
    ---
    
    # Java and Kotlin
    
    ## Purpose
    
    Write JVM code that uses the modern language surface — records, sealed types, pattern matching, coroutines — instead of the 2010-era idioms most JVM codebases are still carrying.
    
    ## When to Use
    
    - Writing or reviewing Java 17+ or Kotlin.
    - Migrating a codebase off Java 8 idioms.
    - Designing domain models with records and sealed interfaces.
    - Introducing coroutines to replace callback or thread-pool code.
    - Diagnosing JVM memory, GC, or startup problems.
    
    ## Capabilities
    
    - Java: records, sealed interfaces, pattern matching for `switch`, virtual threads, `Optional` discipline.
    - Kotlin: coroutines, structured concurrency, flows, null safety, delegation, DSL builders.
    - Java/Kotlin interop, including platform-type null hazards.
    - Build configuration for Gradle (Kotlin DSL) and Maven.
    - JVM tuning: heap sizing, GC selection, JFR profiling.
    
    ## Inputs
    
    - Source module, build file, and target JVM version.
    - Whether the code is a library (binary compatibility matters) or an application.
    
    ## Outputs
    
    - Modern, immutable-by-default domain types.
    - Concurrency that is structured and cancellable.
    - Build configuration pinned to a specific toolchain.
    
    ## Workflow
    
    1. **Model** — Domain values as records (Java) or data classes (Kotlin). Variants as sealed interfaces.
    2. **Match exhaustively** — Use pattern-matching `switch` / `when` so a new variant becomes a compile error.
    3. **Structure concurrency** — Virtual threads (Java 21+) or coroutine scopes tied to a lifecycle.
    4. **Guard nulls at the interop line** — Every value crossing from Java into Kotlin is a platform type; annotate or validate it.
    5. **Gate** — Compile with warnings as errors; run SpotBugs/detekt and the test suite.
    
    ## Best Practices
    
    - Never return `null` from a public API. Return `Optional`, an empty collection, or a sealed "absent" variant.
    - Records are for data, not for behavior with hidden state. Keep them free of mutable references.
    - In Kotlin, `!!` is a defect marker. If you cannot remove it, the type is lying.
    - Never launch a coroutine in `GlobalScope`. It has no cancellation owner.
    - Prefer `runCatching` only in application boundaries; libraries throw typed exceptions.
    - Pin the toolchain in the build file so the JVM version is not an environment variable.
    
    ## Examples
    
    **Sealed model with exhaustive matching (Java 21):**
    
    ```java
    sealed interface Payment permits Card, Transfer, Wallet {}
    
    record Card(String last4, YearMonth expiry) implements Payment {}
    record Transfer(String iban) implements Payment {}
    record Wallet(String provider, String token) implements Payment {}
    
    static String describe(Payment payment) {
        return switch (payment) {
            case Card c      -> "Card ending %s".formatted(c.last4());
            case Transfer t  -> "Transfer to %s".formatted(t.iban());
            case Wallet w    -> "%s wallet".formatted(w.provider());
        };
    }
    ```
    
    **Structured concurrency in Kotlin:**
    
    ```kotlin
    suspend fun loadDashboard(userId: String): Dashboard = coroutineScope {
        val profile = async { userService.profile(userId) }
        val orders  = async { orderService.recent(userId, limit = 10) }
        Dashboard(profile.await(), orders.await())
    }
    ```
    
    ## Notes
    
    - Virtual threads (Java 21) remove most reasons to use a reactive framework for I/O-bound work. They do not help CPU-bound work.
    - `coroutineScope` propagates cancellation to children and rethrows the first failure; `supervisorScope` isolates failures. Choose deliberately.
    - Kotlin's `Flow` is cold. Collecting it twice runs the producer twice — a common source of duplicated API calls.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.