Java refactor

Skill limited-grisaille833/claude-java-plugins/plugins/java-core/skills/java-refactor

Boost Claude Code with Java plugins for Java 8–21 projects, including core, Spring, and quality checks tailored to your target version

Install

npx -y skills add limited-grisaille833/claude-java-plugins --skill java-refactor

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Suggests and applies version-gated Java refactorings. Use when user asks to "refactor this", "clean up this code", "modernize this Java", "simplify this", "extract method", "improve this class", or "make this more idiomatic".

SKILL.md

2.9 KB, as published. Nobody here has run it

Refactor the Java code I've selected or provided. Follow these steps:

Step 1 — Detect Java version

Check pom.xml (<java.version> or <maven.compiler.source>) or build.gradle (sourceCompatibility). If not found, ask: "What Java version are you targeting? (8, 11, 17, 21, or other)"

Step 2 — Apply safe refactorings (all Java versions)

These refactorings are safe regardless of Java version:

Extract method: if a method is longer than 20 lines or has a distinct sub-step, extract it with a descriptive name
Rename for clarity: rename variables, methods, or classes with unclear names
Remove duplication: identify repeated logic blocks and extract to a shared method
Replace magic literals: replace inline numbers/strings with named static final constants
Simplify conditionals: replace nested if/else chains with early returns or ternary where clearer
Remove dead code: delete unreachable branches, unused variables, unused imports

Step 3 — Apply version-gated refactorings (only if target version supports it)

State the minimum Java version required for each suggestion:

Java 8+ — Replace anonymous classes with lambdas: e.g., new Comparator<String>() { ... } → (a, b) -> a.compareTo(b)
Java 8+ — Replace imperative loops with streams: e.g., for-each + list.add → list.stream().filter(...).collect(Collectors.toList())
Java 8+ — Use Optional instead of null returns: e.g., return null → return Optional.empty()
Java 9+ — Use List.of / Map.of: e.g., new ArrayList<>(Arrays.asList(...)) → List.of(...)
Java 10+ — Use var for local variables: where the type is obvious from the right-hand side
Java 16+ — Replace data classes with records: e.g., a class with only final fields, a constructor, and getters → record
Java 17+ — Replace instanceof + cast chains with pattern matching: e.g., if (obj instanceof String) { String s = (String) obj; } → if (obj instanceof String s)

Output format

For each refactoring:

What: one sentence describing the change
Why: one sentence explaining the benefit
Before: the original code snippet
After: the refactored code snippet
Java version required: (e.g., "Java 8+" or "All versions")

Then offer: "Want me to apply these changes to the file?"

Next Steps

After completing refactoring:

If tests don't exist for the refactored code → suggest running /java-test to generate tests
If the refactoring changed public API signatures → suggest running /java-docs to update Javadoc
Remind the user to run their build: mvn compile -q or ./gradlew build -q