Conciseness

The body opens with a one-sentence philosophy ("Lambdas are glue. A callback should name one step of the value flow") and never explains concepts Claude already knows; every rule is skill-specific judgment such as "Add the import. Never turn a callback that copies, normalizes, unwraps, casts, or calls something into an identity helper". Dense but lean — it is above level 4 because there are no over-explanation instances to trim.

Actionability

Copy-paste-ready before/after pairs (e.g., "exhibits.stream().collect(Collectors.toMap(Exhibit::id, Function.identity()))") plus concrete API-level directives ("UnaryOperator.identity() when the declared type is UnaryOperator<T>", "Comparator.comparingInt over comparing for primitives") cover the common cases. The referenced scan command in references/hard-stops.md was verified to be a real, executable rg invocation — matching the fully-executable level-5 anchor.

Workflow Clarity

The 11 numbered steps run from a baseline check ("Check the Java baseline first (build files, toolchains, CI, docs)") to an explicit validation step with checklist ("present and absent values, empty input, nulls, ordering, laziness, exception type and timing, side effects, object identity") and a scan-and-reconcile feedback loop ("reconcile every hit before finishing"). Sequence, checkpoints, and error-recovery loop all match the level-5 anchor.

Progressive Disclosure

A "Reference Bundle" table with a "Load it when" column clearly signals three one-level-deep references (hard-stops.md, functional-style-examples.md, java-functional-api.md), all verified present and substantive on disk. The body keeps the workflow inline while splitting examples, API-baseline tables, and antipattern scans out — matching the well-signaled, one-level-deep level-5 anchor exactly.

Specificity

"Write, review, and refactor Java lambdas, method references, and functional-interface callbacks (Function, Predicate, Supplier, Consumer, Comparator, BiFunction)" names three concrete actions and enumerates the exact constructs and interfaces targeted, with the explicit quality goal "readable and behavior-preserving". This matches the level-5 anchor (multiple specific concrete actions, comprehensive coverage); it is above level 4 because there are no coverage gaps in the action list.

Completeness

It explicitly answers "what" ("Write, review, and refactor Java lambdas... so they stay readable and behavior-preserving") and "when" with concrete trigger phrases ("Use whenever Java code creates or changes a callback passed to a stream, Optional, Map, CompletableFuture, or listener API"). It even adds negative boundaries ("Do not use for stream or Optional semantics themselves"), which is a superset of the level-5 anchor; it is not level 4 because the when-clause is fully explicit, not improvable.

Trigger Term Quality

Natural user phrases are covered comprehensively: "make Java code cleaner or more functional", "identity lambdas (x returning x)", "block or multi-line lambdas", "method references, suppliers, or side-effecting callbacks", plus API surfaces users actually touch ("stream, Optional, Map, CompletableFuture, or listener API"). The clause "even if they never say 'lambda'" explicitly captures the synonymless trigger case, exceeding level 4's "a few natural terms missing".

Distinctiveness Conflict Risk

The niche — how Java callbacks are written, not stream/Optional semantics — is sharply demarcated by "Do not use for stream or Optional semantics themselves, and do not use it to force functional style where a plain loop or branch is clearer". Combined with construct-level triggers (lambdas, method references, functional interfaces), conflict risk with adjacent Java skills is minimal, matching the level-5 anchor.