skills.rest
nimadorostkar
nimadorostkarCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

java-kotlin

Modernize JVM code with records, sealed types, and structured concurrency.

25|3|Updated Jul 14, 2026
Search Tags:#concurrency#java#kotlin#jvm#coroutines#records
One-click install
npx skills add https://github.com/nimadorostkar/Claude-Skills-collection --skill java-kotlin-nimadorostkar
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: java-kotlin
Source: https://github.com/nimadorostkar/Claude-Skills-collection/tree/main/skills/languages/java-kotlin
Command: npx skills add https://github.com/nimadorostkar/Claude-Skills-collection --skill java-kotlin-nimadorostkar

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill addresses the technical debt and inefficiency of using outdated 2010-era Java idioms, helping developers transition to modern, safe, and performant JVM code.

Core Features & Use Cases

  • Modern Language Surface: Implements records, sealed interfaces, and pattern matching for cleaner domain modeling.
  • Concurrency Management: Replaces legacy thread-pool code with structured concurrency using virtual threads or coroutines.
  • Use Case: When migrating a legacy Java 8 codebase to Java 21, use this skill to refactor mutable domain objects into immutable records and replace callback-heavy logic with structured coroutine scopes.

Quick Start

Apply the java-kotlin skill to refactor the current service layer to use sealed interfaces and structured concurrency.

Frequently Asked Questions about java-kotlin

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I migrate legacy Java 8 code to use modern Java 17+ features like records and sealed types?▼

Migrating legacy Java 8 code to Java 17+ involves refactoring mutable domain objects into immutable records and replacing deep inheritance hierarchies with sealed interfaces. This modernizes domain modeling, enforces type safety, and eliminates outdated 2010-era Java idioms.

What is the best way to replace legacy thread-pool code with structured concurrency on the JVM?▼

Replacing legacy thread-pool code with structured concurrency utilizes virtual threads or coroutines to manage lifecycle scopes safely. This modernizes JVM application code by ensuring robust error handling and memory efficiency without the overhead of traditional callback-heavy logic.

How does pattern matching improve type safety when refactoring JVM applications?▼

Pattern matching improves type safety by enforcing exhaustive checks against sealed interfaces and records during compilation. This technique eliminates brittle instance-of chains and ensures robust error handling when modernizing JVM-based application code.

Can I use this approach to refactor Kotlin coroutines alongside Java code?▼

Yes, this approach targets developers migrating to Java 17+ or Kotlin environments by enforcing proper coroutine lifecycle management. It modernizes JVM development by replacing legacy thread-pool code with structured concurrency across both languages.

When do I need to replace callback-heavy logic with structured concurrency scopes?▼

You need to replace callback-heavy logic with structured concurrency scopes when migrating legacy Java 8 codebases to Java 21. This transition ensures robust error handling and proper coroutine lifecycle management in modern JVM environments.

Related Skills

Explore More Software Engineering Skills→
JCETools-PetraJCETools-Petra
16

java-kotlin

Guide Java and Kotlin development with JVM patterns and concurrency models.

Community
Intermediate
tranceetrancee

testing-coroutines-with-runtest

Standardize JVM coroutine testing with kotlinx-coroutines-test and runTest.

Community
Advanced
its-Basudebaits-Basudeba
1

kotlin-patterns

Enforce idiomatic Kotlin patterns, null safety, and structured concurrency for JVM applications.

Community
Advanced
idiaz01idiaz01
3

perl-patterns

Modernize Perl code with 5.36+ syntax, Moo, and Try::Tiny patterns.

Community
Intermediate