Kotlin Tooling Java To Kotlin

JetBrainsOfficialCreated by JetBrainsDistributed by JetBrains

Skill
Workflow
Software development
Apache-2.0
No issues found

From the author

Use when converting Java source files to idiomatic Kotlin, when user mentions "java to kotlin", "j2k", "convert java", "migrate java to kotlin", or when working with .java files that need to become .kt files. Handles framework-aware conversion for Spring, Lombok, Hibernate, Jackson, Micronaut, Quarkus, Dagger/Hilt, RxJava, JUnit, Guice, Retrofit, and Mockito.

— the description by JetBrains

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a disciplined, four-step methodology for migrating Java code to Kotlin. It includes framework-aware guidance for common JVM libraries such as Spring, Hibernate, Lombok, and others. The process emphasizes maintaining behavioral parity through a chain-of-thought approach, checking five specific invariants at each stage to ensure the resulting Kotlin code is idiomatic, safe, and maintainable.

What it does

Scans Java files to detect and load relevant framework-specific conversion guides.
Executes a four-step conversion process: 1:1 translation, nullability audit, collection conversion, and idiomatic transformation.
Validates code against five core invariants at every step to prevent regressions.
Provides instructions for preserving Git history during file renaming.
Offers a checklist for verifying compilation and behavioral consistency.
Handles common pitfalls like keyword conflicts, SAM ambiguity, and platform types.

When to use it

When migrating existing Java projects or individual files to Kotlin.
When you need to ensure converted code follows idiomatic Kotlin patterns.
When working with Java codebases that utilize frameworks like Spring, Hibernate, or Dagger.
When you need to maintain Git blame history while refactoring Java to Kotlin.

Advantages

Reduces manual effort by providing a systematic, repeatable conversion workflow.
Ensures framework-specific idioms are applied correctly through targeted reference guides.
Maintains code integrity by enforcing strict invariants throughout the transformation.
Minimizes common interop issues by addressing platform types and JVM annotations.

Usage examples

“Convert this Java file to idiomatic Kotlin.”: The agent will scan the file for frameworks, perform the four-step conversion, and output the resulting .kt file.
“Migrate my Java project to Kotlin.”: The agent will list all .java files, sort them by dependency order, and perform a batch conversion following the defined workflow.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/jetbrains/kotlin-tooling-java-to-kotlin/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip kotlin-tooling-java-to-kotlin.zip -d .agents/skills

Documentation by JetBrains

Java to Kotlin Conversion

Convert Java source files to idiomatic Kotlin using a disciplined 4-step conversion methodology with 5 invariants checked at each step. Supports framework-aware conversion that handles annotation site targets, library idioms, and API preservation.

Workflow

digraph j2k_workflow {
  rankdir=TB;
  "User specifies files" -> "Step 0: Scan & Detect";
  "Step 0: Scan & Detect" -> "Load framework guides";
  "Load framework guides" -> "Step 1: Convert";
  "Step 1: Convert" -> "Step 2: Write .kt";
  "Step 2: Write .kt" -> "Step 3: Git rename";
  "Step 3: Git rename" -> "Step 4: Verify";
  "Step 4: Verify" -> "Next file?" [label="pass"];
  "Step 4: Verify" -> "Fix issues" [label="fail"];
  "Fix issues" -> "Step 1: Convert";
  "Next file?" -> "Step 0: Scan & Detect" [label="batch: yes"];
  "Next file?" -> "Done" [label="no more files"];
}

Step 0: Scan & Detect Frameworks

Before converting, scan the Java file's import statements to detect which frameworks are in use. Load ONLY the matching framework reference files to keep context focused.

Framework Detection Table

Import prefix	Framework guide
`org.springframework.*`	SPRING.md
`lombok.*`	LOMBOK.md
`javax.persistence.`, `jakarta.persistence.`, `org.hibernate.*`	HIBERNATE.md
`com.fasterxml.jackson.*`	JACKSON.md
`io.micronaut.*`	MICRONAUT.md
`io.quarkus.`, `javax.enterprise.`, `jakarta.enterprise.*`	QUARKUS.md
`dagger.`, `dagger.hilt.`	DAGGER-HILT.md
`io.reactivex.`, `rx.`	RXJAVA.md
`org.junit.`, `org.testng.`	JUNIT.md
`com.google.inject.*`	GUICE.md
`retrofit2.`, `okhttp3.`	RETROFIT.md
`org.mockito.*`	MOCKITO.md

If javax.inject.* is detected, check for Dagger/Hilt vs Guice by looking for other imports from those frameworks. If ambiguous, load both guides.

Step 1: Convert

Apply the conversion methodology from CONVERSION-METHODOLOGY.md.

This is a 4-step chain-of-thought process:

Faithful 1:1 translation — exact semantics preserved
Nullability & mutability audit — val/var, nullable types
Collection type conversion — Java mutable → Kotlin types
Idiomatic transformations — properties, string templates, lambdas

Five invariants are checked after each step. If any invariant is violated, revert to the previous step and redo.

Apply any loaded framework-specific guidance during step 4 (idiomatic transformations).

Step 2: Write Output

Write the converted Kotlin code to a .kt file with the same name as the original Java file, in the same directory.

Step 3: Preserve Git History

To preserve git blame history, use a two-phase approach:

# Phase 1: Rename (creates rename tracking)
git mv src/main/java/com/example/Foo.java src/main/kotlin/com/example/Foo.kt
git commit -m "Rename Foo.java to Foo.kt"

# Phase 2: Replace content (tracked as modification, not new file)
# Write the converted Kotlin content to Foo.kt
git commit -m "Convert Foo from Java to Kotlin"

If the project keeps Java and Kotlin in the same source root (e.g., src/main/java/), rename in place:

git mv src/main/java/com/example/Foo.java src/main/java/com/example/Foo.kt

If the project does not use Git, simply write the .kt file and delete the .java file.

Step 4: Verify

After conversion, verify using checklist.md:

Attempt to compile the converted file
Run existing tests
Check annotation site targets
Confirm no behavioral changes

Batch Conversion

When converting multiple files (a directory or package):

List all .java files in the target scope
Sort by dependency order — convert leaf dependencies first (files that don't import other files in the conversion set), then work up to files that depend on them
Convert one file at a time — apply the full workflow (steps 0-4) for each
Track progress — report which files are done, which remain
Handle cross-references — after converting a file, update imports in other Java files if needed (e.g., if a class moved packages)

For large batches, consider converting in packages (bottom-up from leaf packages).

Common Pitfalls

See KNOWN-ISSUES.md for:

Kotlin keyword conflicts (when, in, is, object)
SAM conversion ambiguity
Platform types from Java interop
@JvmStatic / @JvmField / @JvmOverloads usage
Checked exceptions and @Throws
Wildcard generics → Kotlin variance

Files

ATTRIBUTION.mdAdded by AutoGineer1023 B
LICENSEAdded by AutoGineer10.0 KiB
SKILL.md5.6 KiB
assets/checklist.md2.5 KiB
references/CONVERSION-METHODOLOGY.md9.8 KiB
references/KNOWN-ISSUES.md9.5 KiB
references/frameworks/DAGGER-HILT.md4.3 KiB
references/frameworks/GUICE.md4.5 KiB
references/frameworks/HIBERNATE.md5.9 KiB
references/frameworks/JACKSON.md7.1 KiB
references/frameworks/JUNIT.md5.3 KiB
references/frameworks/LOMBOK.md6.3 KiB
references/frameworks/MICRONAUT.md3.3 KiB
references/frameworks/MOCKITO.md7.7 KiB
references/frameworks/QUARKUS.md3.8 KiB
references/frameworks/RETROFIT.md4.4 KiB
references/frameworks/RXJAVA.md5.6 KiB
references/frameworks/SPRING.md6.3 KiB

references/frameworks/JACKSON.md

Jackson Conversion Guide

When This Applies

Detected when imports match com.fasterxml.jackson.*.

Key Rules

Annotation site targets:
- @JsonProperty on a Java field → @field:JsonProperty in Kotlin.
- @JsonProperty on a Java getter → @get:JsonProperty in Kotlin.
- When converting to Kotlin properties, apply BOTH @field: and @get: targets to match Java's dual annotation on field + getter.
@JsonCreator: Java's @JsonCreator static factory or constructor → Kotlin primary constructor. The @JsonCreator annotation is often unnecessary on Kotlin's primary constructor if using the Jackson Kotlin module, but preserve it for safety.
@JsonIgnore: Preserve exactly. Use @get:JsonIgnore or @field:JsonIgnore depending on original target.
@JsonDeserialize / @JsonSerialize: Preserve exactly with correct site targets.
@JsonInclude: Preserve on class or property level.
@JsonFormat: Preserve with @field:JsonFormat site target.
Jackson Kotlin Module: Note that projects using Jackson with Kotlin should add jackson-module-kotlin for proper Kotlin support (data classes, default values, nullable types). This is NOT something to add during conversion — just note it if missing.
Builder pattern with @JsonPOJOBuilder: Replace with primary constructor + @JsonCreator if converting to data class. Otherwise preserve.

Example 1: DTO with Various Jackson Annotations

Java Input

package com.acme.dto;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonFormat;

/**
 * Data transfer object for an order summary.
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
public class OrderSummaryDto {

    @JsonProperty("order_id")
    private final String orderId;

    @JsonProperty("total_amount")
    private final double totalAmount;

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
    private final String createdDate;

    @JsonIgnore
    private String internalNote;

    public OrderSummaryDto(String orderId, double totalAmount, String createdDate) {
        this.orderId = orderId;
        this.totalAmount = totalAmount;
        this.createdDate = createdDate;
    }

    @JsonProperty("order_id")
    public String getOrderId() {
        return orderId;
    }

    @JsonProperty("total_amount")
    public double getTotalAmount() {
        return totalAmount;
    }

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
    public String getCreatedDate() {
        return createdDate;
    }

    @JsonIgnore
    public String getInternalNote() {
        return internalNote;
    }

    public void setInternalNote(String internalNote) {
        this.internalNote = internalNote;
    }
}

Kotlin Output

package com.acme.dto

import com.fasterxml.jackson.annotation.JsonIgnore
import com.fasterxml.jackson.annotation.JsonInclude
import com.fasterxml.jackson.annotation.JsonProperty
import com.fasterxml.jackson.annotation.JsonFormat

/**
 * Data transfer object for an order summary.
 *
 * @property orderId unique identifier for the order, serialized as `"order_id"`
 * @property totalAmount total monetary amount, serialized as `"total_amount"`
 * @property createdDate date the order was created, formatted as `yyyy-MM-dd`
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
open class OrderSummaryDto(
    @field:JsonProperty("order_id")
    @get:JsonProperty("order_id")
    val orderId: String?,

    @field:JsonProperty("total_amount")
    @get:JsonProperty("total_amount")
    val totalAmount: Double,

    @field:JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
    @get:JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
    val createdDate: String?
) {
    @field:JsonIgnore
    @get:JsonIgnore
    var internalNote: String? = null
}

Key points:

@JsonInclude stays at class level — no site target needed.
@JsonProperty gets both @field: and @get: to match the Java field + getter annotations.
@JsonFormat also gets both @field: and @get: since Java had it on both.
@JsonIgnore gets both @field: and @get: to suppress serialization fully.

Example 2: Class with @JsonCreator Factory Method

Java Input

package com.acme.model;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

/**
 * Immutable configuration entry deserialized from JSON.
 */
public class ConfigEntry {

    private final String key;
    private final String value;
    private final boolean enabled;

    @JsonCreator
    public static ConfigEntry create(
            @JsonProperty("key") String key,
            @JsonProperty("value") String value,
            @JsonProperty("enabled") boolean enabled) {
        return new ConfigEntry(key, value, enabled);
    }

    private ConfigEntry(String key, String value, boolean enabled) {
        this.key = key;
        this.value = value;
        this.enabled = enabled;
    }

    @JsonProperty("key")
    public String getKey() {
        return key;
    }

    @JsonProperty("value")
    public String getValue() {
        return value;
    }

    @JsonProperty("enabled")
    public boolean isEnabled() {
        return enabled;
    }
}

Kotlin Output

package com.acme.model

import com.fasterxml.jackson.annotation.JsonCreator
import com.fasterxml.jackson.annotation.JsonProperty

/**
 * Immutable configuration entry deserialized from JSON.
 *
 * @property key the configuration key
 * @property value the configuration value
 * @property enabled whether this entry is active
 */
data class ConfigEntry @JsonCreator constructor(
    @field:JsonProperty("key")
    @get:JsonProperty("key")
    val key: String?,

    @field:JsonProperty("value")
    @get:JsonProperty("value")
    val value: String?,

    @field:JsonProperty("enabled")
    @get:JsonProperty("enabled")
    val enabled: Boolean
) {
    companion object {
        /**
         * Factory method preserved for documentation; the primary constructor
         * with [JsonCreator] handles deserialization directly.
         */
        @JsonCreator
        @JvmStatic
        fun create(
            @JsonProperty("key") key: String?,
            @JsonProperty("value") value: String?,
            @JsonProperty("enabled") enabled: Boolean
        ): ConfigEntry = ConfigEntry(key, value, enabled)
    }
}

Key points:

The Java @JsonCreator static factory is converted to a Kotlin primary constructor with @JsonCreator. The companion object factory is preserved for backward compatibility but the primary constructor handles deserialization.
The class becomes a data class since it is immutable and value-oriented.
@JsonCreator is kept on the primary constructor for safety, ensuring Jackson can deserialize even without the Jackson Kotlin module.
String parameters remain nullable (String?) since Java strings are nullable by default and there is no @NonNull or Objects.requireNonNull evidence.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs a command-line tool

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

JetBrains

Publisher

JetBrains (Official)

Distributed by

JetBrains

Source

JetBrains/skills · kotlin-tooling-java-to-kotlin · commit 3f53782

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (written by AutoGineer)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by JetBrains.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download kotlin-tooling-java-to-kotlin.zip

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by JetBrains

Java to Kotlin Conversion

Workflow

Step 0: Scan & Detect Frameworks

Framework Detection Table

Step 1: Convert

Step 2: Write Output

Step 3: Preserve Git History

Step 4: Verify

Batch Conversion

Common Pitfalls

Files

references/frameworks/JACKSON.md

Jackson Conversion Guide

When This Applies

Key Rules

Example 1: DTO with Various Jackson Annotations

Java Input

Kotlin Output

Example 2: Class with @JsonCreator Factory Method

Java Input

Kotlin Output

Requirements and compatibility

Security

Attribution and licence

Related skills

Implement

Source Driven Development

Write Swift

Cardputer Buddy

Typescript Pro

Scala Pro

Download ZIP