Java coding agents need precise tool routing. A production-ready workflow matches the immediate task: standard Spring Boot implementation, JUnit tests, Javadoc documentation, extract-method refactoring, architecture boundaries, JPA persistence, Maven build execution, or completed pull request review.
This guide selects source-vetted workflows across five repositories, with at most four cards from any single maintainer source. Four cards come from GitHub, alongside selections from ECC, Jeff Allan, Plugin Agent Marketplace, and Decebal S. Every entry is verified against its primary SKILL.md with install data observed from skills.sh. Specialized framework, library, and build cards carry conditional tier badges and are selected only when their specific technology matches.
How this list was picked
Primary source verification. Every workflow is inspected directly against its linked SKILL.md, verifying concrete execution rules for AI coding agents.
Five independent sources. The catalog spans five repositories with a strict cap of four cards from any single maintainer source. This combines core development workflows with framework and community specialists.
Explicit conditional scope. Framework, vendor, library, and build tool cards display their catalog Conditional tier pill. These tools are selected only when their specific technology stack is present in the project.
Specialists are not defaults. Specialist cards such as Java Maven and Java Code Review address narrow, lower-adoption tasks. They provide focused execution for build configurations and completed diff reviews without acting as default workflows.
Top 10 Java skills at a glance
A comparative index of the top picks. Click any card to navigate directly to its detailed review.
Most install counts are targeted skills.sh search observations from August 29, 2026; java-fundamentals and jpa-patterns were checked on September 26, 2026. Core and conditional labels explain how each skill should be selected.
Service Delivery and Verification
Choose these cards only after checking the repository's build files and framework. Spring Boot, JUnit 5, Spring or Quarkus standards, and the Java 21 architecture workflow are conditional choices, not universal Java defaults.
java-springboot
19.6K installs GitHubConditional · Spring Boot
Best for: A Java service that is already built on Spring Boot
java-springboot is a framework-specific implementation workflow for Spring Boot services. It guides work across application configuration, dependency injection, REST endpoints, JPA persistence, and the tests that verify those boundaries.
Load it only when the repository is demonstrably a Spring Boot application. It is not a general Java implementation skill and should not be selected merely because the task uses Java.
Spring Boot configuration and dependency injection
REST endpoint implementation and boundary checks
JPA persistence changes with surrounding service behavior
Best for: A Java repository using JUnit 5 for unit or integration tests
java-junit focuses on JUnit Jupiter test authoring. It covers test structure, parameterized cases, assertions, and Mockito-based collaboration checks so a change is verified at the right behavioral boundary.
Use it when the project has JUnit 5 in its test setup. First inspect the existing test framework and conventions, since this card is conditional on JUnit Jupiter rather than a default for every Java test task.
Best for: Standards work in a Java 17+ Spring or Quarkus project
java-coding-standards provides Java 17+ coding rules while making framework detection part of the workflow. The agent should inspect the build setup and choose the applicable Spring or Quarkus conventions instead of applying one generic checklist.
Use it for implementation consistency and quality decisions in a supported framework project. It is conditional on the detected Spring or Quarkus setup, so it should not be treated as a universal Java style guide.
Java 17+ language and implementation standards
Build-file detection before choosing framework rules
Spring-specific conventions when Spring is present
Quarkus-specific conventions when Quarkus is present
5.0K installs Jeff AllanConditional · Java 21 / Spring Boot
Best for: Architecture work in a Java 21 Spring Boot service
java-architect is an architecture workflow for enterprise Java applications. It addresses domain-driven design boundaries, WebFlux and JPA tradeoffs, security concerns, and verification for a Spring Boot codebase running on the expected Java version.
Select it when the task changes system boundaries or architectural direction, not for a routine class edit. Confirm the Java 21 and Spring Boot context first because its guidance is intentionally conditional.
Use these cards when the task is about keeping an API understandable, changing structure without changing behavior, or reviewing a completed diff. Documentation and extraction are focused specialties; Java code review is a specialist choice and never the default implementation workflow.
java-docs
10.6K installs GitHubCore specialty
Best for: Javadoc for public Java APIs and types
java-docs focuses on Javadoc for public APIs and types. It covers the tags that communicate parameters, results, exceptions, and relationships, including inheritDoc, while preserving readable code formatting in examples and references.
Choose it when public Java documentation is the deliverable or a contract needs clarification. It is narrower than general technical writing because it keeps the documentation attached to the API's source-level behavior.
Best for: A long or complex method with a clear extraction boundary
java-refactoring-extract-method is a narrow refactoring workflow for turning a long or complex method into smaller named methods. It emphasizes identifying a coherent responsibility, handling parameters and return values correctly, and keeping behavior unchanged.
Use it when a method's length or control flow makes a safe extraction worthwhile. The goal is a compiling, behavior-preserving refactor, not a broad redesign or an excuse to introduce unrelated abstractions.
Identify a coherent extraction responsibility
Choose parameters and return values from data flow
Best for: A completed Java diff needing a language-specific review
java-code-review is a completed-diff review workflow. It looks for Java findings involving null handling, errors, concurrency, resource lifecycle, API behavior, and performance, then reports findings with severity rather than offering generic style commentary.
Load it after implementation when review is the explicit task. Its lower adoption in the canonical Java results makes it a specialist evidence source, not the default card for writing or changing Java code.
Severity-ranked findings from a completed diff
Null, error, concurrency, and resource checks
API and performance regression review
Specific evidence instead of generic review advice
Use core-language guidance for ordinary Java implementation, JPA patterns when Spring persistence is in scope, and Maven only after the repository establishes it as the build system.
Best for: Core Java implementation and language-level refactoring
java-fundamentals covers core Java programming from syntax and object-oriented design to collections, streams, and exception handling across Java 8 through 21. It is the direct language-level option when a task is not already bounded by Spring, JUnit, JPA, Maven, or another specialist workflow.
Use it for clean, idiomatic Java implementation and refactoring decisions. Records, sealed classes, and pattern matching are covered where the project's Java version supports them, so check the configured toolchain before adopting newer language features.
Core syntax, OOP, collections, streams, and exceptions
Java 8 through 21 language features
Records, sealed classes, and pattern matching when supported
Idiomatic implementation and refactoring decisions
Best for: Spring Boot persistence work involving JPA or Hibernate entities and queries
jpa-patterns covers Spring Boot JPA and Hibernate work from entity and relationship design through transactions, indexing, pagination, pooling, auditing, and query optimization. It gives an agent a direct workflow for a common Java service boundary rather than a vendor-specific cloud client integration.
Use it when a Spring Boot project needs persistence changes or a Hibernate issue such as N+1 queries, fetch strategy, or transaction behavior needs investigation. It is conditional on JPA/Hibernate being part of the application, not a substitute for general Java implementation guidance.
Entity and relationship design for Spring Boot JPA
Best for: Build work in an existing Maven Java project
java-maven is a build-focused workflow for Maven projects. It addresses lifecycle phases, dependency management and BOMs, and diagnostics for multi-module builds so failures are investigated against the project's effective model.
Use it only after pom.xml files or the build commands establish Maven as the build system. Its lower adoption in the canonical Java results means it is a conditional specialist, never a default for Java build or implementation work.
Select a card only after matching its trigger to the project. Use framework, runtime, cloud, and build cards only when their technology is present. Java Maven and Java Code Review are focused specialists with lower adoption, designed for targeted tasks rather than general development defaults.
1.Implement standard services, unit tests, and documentation. When the repository uses Spring Boot, use its workflow for controllers, service layers, and data repositories. Load the dedicated testing skill when writing JUnit 5 suites or mock assertions, and invoke the documentation workflow when drafting public Javadoc comments or extracting dense methods into readable helpers.
2.Distinguish framework conventions from architecture boundaries. Apply framework conventions for dependency injection, annotations, and configuration properties. Switch to the architecture workflow when establishing domain boundaries, hexagonal layer isolation, or package decoupling across enterprise modules.
3.Use core Java and JPA guidance at the right boundary. Use Java Fundamentals for ordinary language-level implementation and refactoring. Load JPA Patterns only when a Spring Boot service uses JPA or Hibernate for entity design, relationships, query tuning, or transaction behavior.
4.Apply Maven and code review specialists for specific phases. Use Java Maven specifically for pom.xml dependency management, plugin executions, and multi-module build troubleshooting. Run Java Code Review after completing a change to verify null safety, concurrency contracts, and memory efficiency across the finished diff.
Framework standards versus application architecture
Spring Boot and enterprise frameworks provide established conventions for bean wiring, configuration binding, and endpoint routing. These conventions ensure idiomatic code within a given stack, but they do not automatically solve system architecture.
Keep business logic independent from framework annotations where domain clarity is required. Use architectural guidance to define clean interfaces, manage dependency direction, and enforce modular boundaries. When implementing specific endpoints or repository beans, rely on framework-specific standards to keep configuration concise and idiomatic.
Core Java, persistence, and build discipline
These workflows solve separate development boundaries. Java Fundamentals covers idiomatic language features and common standard library work from Java 8 through 21. JPA Patterns handles the Spring Boot persistence layer, including entity relationships, transactions, query design, and N+1 prevention.
Keep build configurations in Maven clean by managing plugin lifecycles and dependency scopes deliberately. Once implementation is complete, run a focused code review across the diff to audit thread safety, resource cleanup in try-with-resources blocks, and proper exception hierarchies before merging.
Keep Java skills visible with LazySkills
LazySkills scans installed skills, shows which agents can see them, diagnoses broken configurations, and searches the same skills.sh registry used for this guide. Install the catalog manager, then add the focused Java workflow that matches your active project.
Conditional cards are selected from repository evidence, not from the language name alone. Confirm Spring Boot, JUnit 5, Spring or Quarkus, Java 21 with Spring Boot, JPA or Hibernate, or Maven before loading the matching card. A plain Java task should not inherit framework-specific instructions.
When should an agent use extract-method refactoring?
Use java-refactoring-extract-method when a method is long or complex and contains a coherent responsibility that can be named. The extraction should follow data flow, preserve observable behavior, and compile with verification. It is not a general redesign workflow.
How do coding standards, architecture, and code review differ?
java-coding-standards chooses Java 17+ rules from a detected Spring or Quarkus build setup. java-architect handles Java 21 and Spring Boot architectural boundaries such as DDD, WebFlux, JPA, and security. java-code-review examines a completed diff for severity-ranked Java findings. Review is not a substitute for implementation or architecture work.
Are Maven and Java code review default skills?
No. java-maven has lower adoption and should be loaded only when the repository clearly uses Maven and the task concerns its lifecycle, dependencies, BOMs, or modules. java-code-review also has lower adoption and is reserved for an explicit completed-diff review. The canonical search evidence supports both as specialists, not defaults.
Which card covers Java service implementation and tests?
Use java-springboot only for a Spring Boot service, and use java-junit when the repository uses JUnit 5 and testing is the center of the task. For a framework-independent Java change, inspect the repository's own conventions first rather than forcing either conditional card.
svgdiagram.ai 
