16 skills · 8 categories
Claude Code skills for Java and Kotlin on the JVM
JVM skills for modern Java and Kotlin: records and sealed types, Spring Boot services, Gradle builds, virtual threads and the observability setup that makes a JVM service debuggable in production.
Start with these
- 1
Modern Java
Records, sealed types, and virtual threads done right
Claude writes Java that uses what the language finally offers: immutable records with compact-constructor validation, sealed hierarchies matched by exhaustive switch with record patterns and no default branch, and virtual threads for blocking I/O with semaphores instead of pools. It upgrades legacy 8, 11 and 17 codebases in a safe order, build tooling first.
- 2
Spring Boot
Typed config, honest JPA and fast test slices
Claude writes Spring Boot code with constructor injection, validated configuration records, and explicit JPA fetch plans instead of relying on open-session-in-view. Errors come back as ProblemDetail, tests use the narrowest slice with Testcontainers rather than H2, and Actuator exposes health probes and metrics without leaking env or heap dumps.
- 3
Kotlin Idioms
No !!, no GlobalScope, no leaked coroutines
Claude writes Kotlin that resolves nulls at the edge, models screens and results as sealed types with exhaustive when, and launches every coroutine in a scope something owns. It picks Flow, StateFlow, SharedFlow or Channel deliberately, keeps suspend functions main-safe, rethrows CancellationException, and tests timing with virtual time instead of sleeps.
All 16 Java and Kotlin on the JVM skills
Grouped by category. Each card opens the full playbook, example prompts and install commands.
Languages 3
Modern Java
Records, sealed types, and virtual threads done right
Claude writes Java that uses what the language finally offers: immutable records with compact-constructor validation, sealed hierarchies matched by exhaustive switch with record patterns and no default branch, and virtual threads for blocking I/O with semaphores instead of pools. It upgrades legacy 8, 11 and 17 codebases in a safe order, build tooling first.
Kotlin Idioms
No !!, no GlobalScope, no leaked coroutines
Claude writes Kotlin that resolves nulls at the edge, models screens and results as sealed types with exhaustive when, and launches every coroutine in a scope something owns. It picks Flow, StateFlow, SharedFlow or Channel deliberately, keeps suspend functions main-safe, rethrows CancellationException, and tests timing with virtual time instead of sleeps.
Regex Crafting
Patterns with test cases and no ReDoS surprises
Claude writes regexes test-first: a cases file of must-match, must-not-match and expected captures, then the simplest anchored pattern that passes. It knows where PCRE, JavaScript, Python, Java, Go and grep disagree, rewrites nested quantifiers and overlapping alternations, and runs a bundled script that pumps inputs to expose catastrophic backtracking before it ships.
Testing 4
Benchmark Testing
Faster means significant, not one lucky run
Claude stops quoting single-run timings. It uses the right harness per language, guards against dead-code elimination, quiets the machine, measures noise with an A/A run, and compares 10 or more samples per side with a significance test and confidence interval. CI gates get thresholds derived from measured noise, or instruction counts when shared runners are too jittery.
Fuzz Testing
Throw hostile bytes at parsers before attackers do
Claude picks the input boundaries worth fuzzing, writes fast deterministic harnesses with real invariants such as round-trip equality, and seeds them with real inputs and format dictionaries. Crashes get reproduced, minimized, classified by sanitizer report and deduplicated by stack, then committed as regression inputs, and CI runs short fuzz jobs with a cached corpus.
Mutation Testing
Find out if your tests would notice a real bug
Claude runs mutation testing where it pays off, on critical modules or changed files, and triages every surviving mutant: missing boundary case, weak assertion, untested error path, equivalent mutant, or dead code. Survivors turn into small behavior-named tests, ignores carry a written reason, and CI gates only the modules that matter.
Testcontainers
Real databases in tests, started once and reset fast
Claude replaces database mocks and H2 stand-ins with the production engine in a container, started once per run rather than per test. It runs the real migrations, picks rollback, truncation, template databases or snapshots for isolation, gives each parallel worker its own database, and sets up GitHub Actions or GitLab Docker-in-Docker so the suite passes cold, shuffled and in parallel.
Performance 2
JVM Tuning
GC logs and JFR first, then a short flag set with reasons
Claude starts by recording the JDK version, collector, heap, container limits and a stated latency goal, then gathers GC logs and a Flight Recorder capture under real load. It classifies the problem, such as humongous allocations, an undersized heap, native memory overrun or CPU throttling, fixes allocation causes before flags, and ends with a short flag set where every entry has a reason.
Memory Leak Hunting
From growing heap to the exact retaining reference
Claude separates real leaks from warming caches by repeating one action with forced GC, then uses the three-snapshot comparison to find object types that grow per round. It follows the retainer chain to the first reference your code owns, such as a listener, timer, unbounded Map or uncleaned effect, fixes it, and reruns the same loop to show flat memory.
Mobile 3
Kotlin Multiplatform
Share the logic, keep the native feel on Android and iOS
Claude decides what belongs in commonMain and what stays native, builds the shared module with the AGP 9 Android-KMP plugin, Ktor and SQLDelight or Room KMP, and designs a Swift-facing facade with @Throws and SKIE so iOS code gets async functions and exhaustive enums. It treats Swift export as Alpha and plans adoption one slice at a time.
Android Architecture
Layers, Hilt and modules that keep Android apps testable
Claude restructures Android apps along the official layered model: ViewModels expose one StateFlow UiState, repositories make Room the source of truth and keep DTOs internal, Hilt binds interfaces through KSP, and long work moves to WorkManager instead of GlobalScope. It splits modules with a strict dependency direction and convention plugins, and backs each layer with fake-based JVM tests.
Jetpack Compose
Stateless screens, StateFlow state, no recomposition storms
Claude structures Compose screens as a route that collects one immutable UI state with collectAsStateWithLifecycle and a stateless screen that takes state and lambdas. It picks the right effect API with correct keys, applies Scaffold insets for edge-to-edge, and fixes slow lists with keys, deferred state reads and stable models, confirmed with Layout Inspector counts and compiler reports on a release build.
Install
Every Java and Kotlin on the JVM skill in one command
Installs into ~/.claude/skills/. Add --project after -- to install into the current repository.
curl -fsSL https://claudeskills.page/install.sh | sh -s -- java-modern spring-boot kotlin-idioms jvm-tuning kotlin-multiplatform modular-monolith android-architecture jetpack-compose codemods regex-crafting benchmark-testing fuzz-testing mutation-testing testcontainers opentelemetry memory-leak-hunting Java and Kotlin on the JVM skills FAQ
What is the best Claude Code skill for Java and Kotlin on the JVM?
Start with Modern Java: Records, sealed types, and virtual threads done right. Then add Spring Boot and Kotlin Idioms, which cover the next most common Java and Kotlin on the JVM requests.
How do I install all 16 Java and Kotlin on the JVM skills at once?
Pass every name to the installer in one command: curl -fsSL https://claudeskills.page/install.sh | sh -s -- java-modern spring-boot kotlin-idioms jvm-tuning kotlin-multiplatform modular-monolith android-architecture jetpack-compose codemods regex-crafting benchmark-testing fuzz-testing mutation-testing testcontainers opentelemetry memory-leak-hunting. Add --project to install them into the current repository's .claude/skills/ folder so your team gets them too.
Do these Java and Kotlin on the JVM skills work outside Claude Code?
Yes. Each skill uses only the portable Agent Skills frontmatter, so the same folder works on claude.ai, through the Claude API and in the Agent SDK. Skills that run bundled scripts need an environment with code execution.