symphony-trello: Skill for Codex

Java Streams Eval Capture

Goal

When a Symphony for Trello change provides a reusable stream, collector, direct result-producing collection API, or character-predicate equivalence lesson, preserve the teaching example for the Java Streams skill. This includes cases where a direct owning API is better than a stream or where a useful stream-equivalence pattern appears inside another fluent API. Create or update an issue in martinfrancois/java-streams-skill that stands on its own: it must include the relevant code before the refactor, the prompt or review request that triggered the change, the intermediate or rejected implementation when one exists, the final preferred code, and why the final code is better.

When the stream improvement is prompted by a reviewer or user after Codex introduced the weaker stream shape, also capture the earlier prompt that caused Codex to write that shape. The eval issue must make the trigger failure explicit: the Streams skill should have activated during the original implementation prompt, not only during the later stream-refactor request.

When a later request reveals only that activation or eval capture was missed, even though the implementation was already preferred, capture both prompts and state that no code correction was needed. The eval must reward recognizing and capturing the reusable lesson without inventing a defect.

When a stream refactor is later found to be non-equivalent, over-allocated, over-abstracted, or worse than the original code, capture the full correction chain. Include the original code, the prompt that produced the weaker stream code, the weaker code, the later correction/revert prompt, and the final code. The eval must teach the skill to preserve behavior by default, and to call out any mutability, ordering, laziness, parser, exception, allocation, or side-effect change explicitly before recommending it.

When To Use

Use this skill whenever you:

• refactor Java code to use streams more clearly, lazily, or safely;
• replace a loop with a stream or a stream with a clearer stream shape;
• replace or remove a stream with a stronger direct collection API where the choice or equivalence boundary is reusable;
• simplify result-producing collection work inside Optional.map(...) or a similar fluent mapping when the collection transformation itself presents a reusable lesson, even when the final code contains no .stream();
• replace a loop or character scan with a primitive stream and a match terminal when empty-input, UTF-16, or code-point semantics matter;
• replace an identity string reduction such as .reduce("", String::concat) with Collectors.joining(), even when a related delimiter reduction was already captured;
• fix stream short-circuiting, ordering, allocation, collector, Optional, or pipeline readability problems;
• accept a user-provided streams refactor;
• correct a streams refactor after review feedback;
• revert or repair a stream refactor because it changed behavior, allocation, mutability, ordering, laziness, parser semantics, or side-effect boundaries.