Camel Route Developer
Apache Camel route development guidance from a Camel committer, covering route design, integration patterns, endpoint configuration, and practical implementation checks for JVM integration applications.
Opinionated by default — tell your agent to adjust any skill to your stack.
Know what works in production? + Submit a skill
Apache Camel route development guidance from a Camel committer, covering route design, integration patterns, endpoint configuration, and practical implementation checks for JVM integration applications.
Scaffold Spring Boot projects via start.spring.io with fullstack frontend support (Vue, React, Angular, vanilla JS), PostgreSQL, Docker Compose, and Testcontainers. Follows Julien Dubois' defaults.
Typed Gemini Java SDK usage from the SDK author, with Java examples and SDK-native interaction patterns rather than generic REST operations.
Curated JVM skill collection covering Quarkus, Micronaut, modern Java, Maven, testing, observability, profiling, and related framework practices. Uses self-contained skill directories with co-located references and verified APIs.
Adam Bien's guidance for building Jakarta EE and MicroProfile servers, filling the directory's Jakarta EE gap with concise, practical JVM server conventions.
Kotlin Multiplatform Firebase integration using native Android and iOS SDKs through an interface-injection pattern, avoiding third-party KMP wrappers while keeping shared contracts clean.
Expert guidance for Project Reactor on the JVM: operator selection (Mono, Flux, flatMap vs concatMap, switchMap, zip, expand), schedulers and threading, backpressure tuning, Reactor Context propagation (MDC, Micrometer, Spring Security), blocking-to-reactive bridging, R2DBC patterns and reactive transactions, WebClient/reactor-netty configuration, Kotlin coroutine/Flow interop, testing with StepVerifier, and debugging with checkpoint/log/ReactorDebugAgent/BlockHound.
Quarkus extension development guidance with build-time/runtime separation, extension structure, version-specific behavior, and verified LTS deltas.
Quarkus and LangChain4j scaffolding guidance with real in-directory templates for building JVM agentic applications on Quarkus.
Restart the app via IntelliJ run configuration and wait until ready. Skips restart for template changes where LiveReload handles it automatically.
Version-pinned Spring Batch 6 guidance for writing new batch jobs, migrating from 5.x, reviewing API changes, and debugging Spring Batch applications.
Migrates Spring Boot 3.x applications to 4.x and tracks 4.x minor-version changes. Covers build/starter changes, Jackson 3, Spring Security 7, Spring Framework 7, observability (OpenTelemetry/Micrometer), property and package relocations, testing (JUnit 6, Testcontainers 2, MockitoBean), HTTP clients, resilience, AOT/native, and API versioning. Includes all-at-once and gradual upgrade strategies with compatibility bridges and a verification script.
Enterprise Spring Boot 3.x patterns: layered architecture with constructor injection, Spring Security with OAuth2, Spring Data JPA repositories, Actuator health checks, and integration testing with @SpringBootTest.
Opinionated Spring Boot 4.x modular-monolith scaffolding (SivaLabs style): package-by-feature + Spring Modulith boundaries, Thymeleaf server-side rendering, ArchUnit/Taikai architecture tests, Docker Compose dev services, and a Maven build-quality setup (Spotless, JaCoCo gate, buildpacks). Maven-only, Boot 4.x.
Version-aware Spring Boot coding across the 3.5.x↔4.0.x boundary — detects Boot/Java versions and applies the right APIs (Jackson 2/3, @MockitoBean vs @MockBean, built-in @GetMapping versioning), plus virtual-thread discipline, JSpecify/NullAway build wiring (Maven + Gradle), and Micrometer/OpenTelemetry observability. Delegates deep migration/JSpecify to sibling skills.
Comprehensive Java 21 best-practices guidance with verified APIs, opinionated implementation rules, and a broad pattern catalog that supersedes weaker code-quality and design-pattern listings.
Dense, opinionated Java 25 coding conventions for modern Java applications, including concrete style, API, and implementation rules from Adam Bien.
A curated bundle of Java LTS upgrade guides covering 8→11, 11→17, 17→21, and 21→25 with JEP-by-JEP migration guidance and worked code examples.
Kotlin API design and binary-compatibility review guidance, including default-argument ABI behavior, @JvmOverloads limits, @PublishedApi, explicit API mode, and compatibility validation.
Kotlin language-feature guidance covering recent Kotlin 2.2 and 2.3 behavior, with verified feature details and practical usage advice for modern Kotlin/JVM code.
Logging best practices with SLF4J, structured JSON logging, and MDC for request tracing. Includes AI-friendly log formats optimized for Claude Code debugging and correlation ID patterns.
Java Optional best practices for implementation, review, and cleanup. Covers Optional shape selection, isPresent()+get() and orElse(null) antipatterns, lazy fallback with orElseGet(...), primitive Optionals, stream interop, findFirst()/findAny() semantics, and checked-IO boundaries.
Kotlin refactoring guidance for safely converting Java POJOs to data classes, including componentN ordering, public API compatibility, sensitive toString exposure, and field-order hazards.
Java Streams, Collectors, and Gatherers best practices for implementation, review, and cleanup. Covers terminal operation choice, ordering and null behavior, collector semantics, primitive streams, duplicate-key and comparator pitfalls, Java-version-specific APIs, and when parallelStream() is actually appropriate.
Comprehensive reference covering PostgreSQL table design, data types, indexing strategies, constraints, JSONB patterns, partitioning, and PostgreSQL-specific best practices. Covers update-heavy, upsert-heavy, and OLTP-style table patterns.
Reviews Hibernate/JPA code in the spirit of Hypersistence Optimizer: identifier strategies, entity mappings, association and fetch design, N+1 detection, query optimization, batch processing, transactions and locking, Spring Data JPA anti-patterns, schema migrations, and Hibernate 6 features. Runs the full checklist on every entity review.
Comprehensive jOOQ DSL best practices for Kotlin/Java. Expert knowledge base covering SQL patterns, transactions, multiset nesting, code generation, Spring Boot integration, and PostgreSQL-specific features.
Oracle OKafka Java-client guidance with JVM-specific client configuration, examples, and integration patterns for Oracle Database-backed Kafka APIs.
Setting up vector similarity search with pgvector for AI/ML embeddings, RAG applications, or semantic search. Covers halfvec storage, HNSW index configuration, quantization strategies, filtered search, and performance tuning.
Implementing hybrid search combining BM25 keyword search with semantic vector search using Reciprocal Rank Fusion (RRF). Covers pg_textsearch BM25 index setup, parallel query patterns, client-side RRF fusion, and optional ML reranking.
Compose Desktop UI testing through an HTTP control server, using a real Maven Central library and reusable testing patterns without project-specific Release Wizard coupling.
Run Kover coverage via Gradle, identify packages and classes below coverage thresholds, and generate a prioritized test improvement plan.
Multi-agent debugger orchestrator that drives JDB CLI to set breakpoints, step through code, and collect thread dumps. Each capability is packaged as a reusable agent skill, making the toolkit readily callable from AI coding agents.
Write a new Kotlin test, or modernize an existing one, using Kotest matchers and idiomatic Kotlin test style — backticked names, apply/assertSoftly blocks, and existing object mothers and helpers. Preserves assertion semantics when modernizing, and verifies with a focused test command. Framework-neutral — project-specific context (base classes, test annotations, single-test command) plugs in via a local `references/project.md` overlay.
Bootstrap pitest via the info.solidsoft.pitest Gradle plugin with Kotlin-sane defaults, run scoped mutation tests derived from git diff, interpret surviving mutants from mutations.xml, triage likely-equivalent mutants (logger gates, unreachable loop bounds, null-elvis on non-nullable values) into a separate bucket, and drive a kill-survivor workflow that hands each likely-killable survivor to /tdd-task. Non-intrusive — mutates bytecode, no production-code changes required.
Run an autonomous Ralph loop that improves test coverage by iteratively picking the least-covered class, writing meaningful tests for it, and committing — one class per iteration until a target threshold is reached. Ships a single-run script and a headless N-iteration loop.
Implement a feature or fix a bug using strict TDD — plan a todolist, clarify ambiguities before coding, write a failing test first, then implement the minimum to pass, refactor, verify (with an E2E test for user-observable changes), and commit. Enforces red-green-refactor with mandatory gates.
Run Gradle tests headlessly with optional filter patterns. Returns raw failure output to the caller — does NOT fix failures. Fix-or-report separation keeps test runs cheap and predictable.
Verify UI/UX by running Playwright tests and reviewing screenshots. Spawns a ui-review subagent to check layouts, user flows, and visual correctness. Iterates until the page looks right.
TDD-driven bug fixing: write a failing test first, implement the fix, refactor, then verify. Automatically picks the right test type — integration with DB, mocks/stubs, or end-to-end browser.
Break out of generic AI-generated UIs. Opinionated design system covering typography scales, color themes, motion choreography, spatial composition, and layered background effects.
Optimize web performance for faster loading and better user experience. Covers Core Web Vitals, critical rendering path, image optimization, font loading strategies, caching, and third-party script management.
Group uncommitted changes into logical feature commits with concise, action-oriented messages. Avoids conventional commit prefixes.
Interview user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Outputs a spec with user stories that cover all roles, entry points, and edge cases.
Rebase non-pushed commits and uncommitted changes into clean logical feature commits using vertical-slice grouping. Preserves incremental slices as separate commits while merging related fixes.
Six-step spec-driven development workflow bundle for turning a proposal into acceptance criteria, rules, review, task plans, and execution checkpoints. Listed as a cohesive workflow bundle rather than isolated generic workflow singles.
Generate a feature spec with user stories from conversation context and codebase exploration. Proactively resolves unknowns by mining conversation, exploring code, and reading docs — no interview needed.
Browser automation CLI for AI agents. Navigate, fill forms, click, take screenshots, scrape data, and run exploratory QA via Chrome/Chromium over CDP. Covers browsers, Electron apps, Slack, and cloud browser backends.
Zero-dependency Java 25 single-file scripting guidance with shebang execution, PATH installation, and practical CLI patterns without a build tool.
Java Flight Recorder analysis workflow for offline .jfr recordings, covering event-type semantics, native jfr CLI usage, lock contention, allocation, GC, and noise-filtering strategies.
JSpecify provides annotations to explicitly declare nullness expectations of Java code. Adds jspecify dependency and configures Maven or Gradle builds with ErrorProne/NullAway for compile-time nullability checking. Helps prevent NullPointerExceptions.
JVM live diagnostics with jstall: deadlock detection, flame graphs, GC and classloader analysis, JIT queue inspection, and focused commands for investigating running Java processes.
Kotlin REPL prototyping workflow using kotlinc -Xrepl and focused experimentation techniques for Kotlin/JVM code before committing changes.
Migrates Maven JVM projects to Gradle Kotlin DSL with version catalogs, covering single-module and multi-module builds, Spring Boot parent POMs, Maven profiles, dependency scope mapping, BOM imports, annotation processors, plugin mappings, and dual-build overlay mode.
Java codebase migration assessment using Konveyor MTA and kantra, including custom rules, target platform analysis, blocker detection, and effort estimation for JVM migrations.
Transferable macOS signing and notarization workflow for JavaFX/jpackage applications, including jlink, notarytool, and JVM-native crash-diagnostic considerations.
Guidance for using the qs-kotlin query-string library with its verified defaults and source-backed API behavior, focused on Kotlin/JVM request serialization and parsing.
JVM PDF security validation with Apache PDFBox, covering attachments, XFA, JavaScript, launch and GoToR links, import actions, concatenation detection, and file-size safeguards.
Missing a skill for your stack? + Submit a skill
$ grep: no matches found
Try adjusting your filters or search term.
curl -fsSL jvmskills.com/install | sh — auto-detects your stack from build files, picks matching skills, and generates AI config. Zero dependencies.
Skills compose from a base + language/database overlays. Detect jOOQ + Kotlin + PostgreSQL? You get the base skill plus only the overlays that matter.
Claude Code is the v1 target. The same skill content compiles to Cursor, Copilot, Windsurf, Aider, and Codex formats — one source of truth, every editor.