functional-programming

I was digging through the functional-programming skill and noticed you're handling composition patterns pretty thoroughly—curious how you settled on your approach to currying, since that's where a lot of folks hit friction with the learning curve.

Links:

• GitHub
• Your agentic skill in the SkillzWave marketplace

The TL;DR

You're at 74/100, solid C-grade territory. This is based on Anthropic's 5-pillar rubric for skill quality. Your strongest area is Spec Compliance (12/15)—the YAML frontmatter and naming are dialed in. Weakest pull is Progressive Disclosure Architecture (20/30)—the single-file approach works for 40 lines, but you're losing depth points for not layering content. Real talk: two high-severity fixes could bump you up 4 points pretty easily.

What's Working Well

• Spec Compliance is locked down (12/15)—Valid YAML, correct naming conventions, required fields all present. No friction there.
• Clear trigger phrasing in your description—"Use when writing functional code" is obvious enough that developers know when to activate this. That's worth something.
• The Quick Start example actually runs—[1, 2, 3] /> map(double) /> filter((x) -> x > 2) is a real pipeline showing composition. That beats vague explanations.
• No fluff language—Your writing stays technical and objective. No marketing speak creeping in.

The Big One: Missing Workflow for Pattern Selection

Here's what's holding you back: developers using this skill have no decision tree for when to apply FP patterns versus alternatives. You list Core Principles as bullets, but there's no "use pure functions when [X], use pipes when [Y], use maybe when [Z]" framework.

Why it matters: FP in Lea isn't universal—sometimes imperative is clearer. Without guidance on when to choose FP, ...