142-java-functional-programming

Use when you need to apply functional programming principles in Java — including writing immutable objects and Records, pure functions, functional interfaces, lambda expressions, Stream API pipelines, Optional for null safety, function composition, higher-order functions, pattern matching for instanceof and switch, sealed classes/interfaces for controlled hierarchies, Stream Gatherers for custom operations, currying/partial application, effect boundary separation, and concurrent-safe functional patterns. This should trigger for requests such as Improve the code with Functional Programming; Apply Functional Programming; Refactor the code with Functional Programming; Refactor Java code to use streams or Optionals safely; Improve immutability and pure functions in Java. Part of Plinth Toolkit

Quality

80%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/142-java-functional-programming/SKILL.md

Quality

Content

63%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

The body is well-organized with a clear, validated workflow and good progressive disclosure to a single reference file. It is weakened by redundancy with the description and by abstract, code-free guidance for the core refactoring task.

Suggestions

Remove the 'When to use this skill' section (or trim it to a one-line pointer) since it duplicates the description's trigger phrases verbatim and consumes tokens without adding new information.

Add 1-2 short inline good/bad code snippets (e.g., Optional map/orElse vs isPresent+get, or a Stream pipeline) so the core refactoring guidance is actionable without forcing a reference read for common cases.

Collapse the Constraints bullets that overlap the Workflow steps (compile/verify) into the workflow itself, or keep Constraints only for the edge-case handling that the workflow does not already state.

Dimension	Reasoning	Score
Conciseness	Mostly efficient but padded: the 'When to use this skill' list verbatim-duplicates the description's trigger phrases and 'What is covered' largely restates the description's capability enumeration, while the Constraints section overlaps the Workflow steps; not a 4 because the redundancy is noticeable rather than minor.	3 / 5
Actionability	Concrete build commands (./mvnw compile, mvn clean verify) and a real reference path are present, but the core functional-refactoring guidance is abstract ('identify opportunities', 'implement selected functional refactorings') with no inline code patterns; not a 4 because the key executable details for the actual task are deferred rather than present with minor gaps.	3 / 5
Workflow Clarity	A clear 5-step sequence with explicit pre-validation (compile, stop-on-fail), a Java-compatibility check, and post-validation (clean verify); not a 5 because the recovery action is 'stop' rather than a fix-and-retry loop and there is no checklist for the multi-pattern refactoring.	4 / 5
Progressive Disclosure	The body is a well-sectioned overview (What is covered, Scope, Constraints, When to use, Workflow, Reference) pointing to a single one-level-deep reference (references/142-java-functional-programming.md, confirmed present) signaled twice via markdown link, matching the top anchor.	5 / 5
	Total	15 / 20 Passed

Description

96%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

The description is comprehensive and well-structured, explicitly covering both capabilities and concrete trigger phrases with natural user language. Its only weakness is mild overlap risk with sibling Java/plinth-toolkit skills.

Dimension	Reasoning	Score
Specificity	Lists many concrete capabilities (immutable objects/Records, pure functions, functional interfaces, lambdas, Stream API pipelines, Optional, pattern matching, sealed classes, Stream Gatherers, currying) — comprehensive coverage matching the score-5 anchor; not the 4 anchor because coverage is broad rather than having only minor gaps.	5 / 5
Completeness	Clearly answers 'what' (the enumerated functional capabilities) and 'when' ('Use when you need to apply...', 'This should trigger for requests such as...') with concrete trigger phrases, matching the score-5 anchor exactly.	5 / 5
Trigger Term Quality	Explicit trigger phrases such as 'Improve the code with Functional Programming', 'Apply Functional Programming', 'Refactor Java code to use streams or Optionals safely' are natural user utterances with synonyms (streams, Optionals, immutability, pure functions); file extensions do not apply to this Java niche, so it sits at the top anchor rather than below.	5 / 5
Distinctiveness Conflict Risk	The functional-programming-in-Java niche is distinct with specific triggers, but 'Part of Plinth Toolkit' implies sibling Java skills and 'Refactor Java code to use streams or Optionals safely' could overlap a general Java refactoring skill, leaving minor overlap risk rather than minimal.	4 / 5
	Total	19 / 20 Passed

Validation

100%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository: jabrena/plinth
Path: skills/142-java-functional-programming/SKILL.md
Commit: f6dfc6f

Reviewed: 15 minutes ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.