The Jev Skill Family: Five Workflow Primitives for Coding Agents (Evaluated)

Five skills from one 471-star repo, all evaluated this week. Two score above 9, all five score 10 on security — a first in 600+ evaluations. Here's what they do, how they compose, and where they're weak.

Most skills in the ecosystem are single prompts: one job, one file, hopefully one good trigger description. Every so often something different lands — a family of skills engineered as a system, each member doing one kind of judgment, designed to be composed.

That's Jev (471★, MIT, CI-tested, 108 documented scenarios). The repo's own one-liner is the best summary I've found: "Jev chooses, classifies and scores. Your agent supplies evidence and takes action."

The division of labor matters. These skills don't browse, don't execute, don't send anything. They make one specific kind of decision well, hand the result back, and let your agent own the consequences. We evaluated all five on the usual six dimensions. Here they are, best first.

1. jev-triage — 9.2/10

Classification and prioritization for inboxes, support tickets, feedback, any record stream — especially bulk parallel judgments.

Why: The standout, and the best-engineered skill in the family. The detail that earned it: smoke_test — before any bulk run, the host agent writes and validates a task-specific pilot on a few paired records, then scales up. That's the difference between "the model sorted 4,000 tickets" and "the model proved its labels on 20 tickets before touching 4,000." It also ends where it should: it produces labels and review queues, not replies and not automatic mailbox changes.

The one thing: Bulk judgment quality lives and dies on per-record context. If your tickets are two-line fragments referencing a internal tool, no skill saves you.

2. jev-eval — 9.1/10

Judges supplied outputs against explicit criteria — code-change reviews, rubric judgments, batch evaluation, multi-turn and team transcripts.

Why: This is the skill you want reviewing pull requests at scale: evidence-backed review leads tied to criteria you defined, not vibes. The boundary is stated twice in the skill itself and worth quoting: not permission to merge or run targets. It scores engineering 10/10 — the evaluation workflows are documented with recorded input/output pairs you can inspect before trusting them.

The one thing: Garbage criteria, garbage judgment. The skill is explicit that you own the rubric — spend your effort there.

3. jev-documents — 8.6/10

Locates, selects, extracts and verifies evidence in documents or observed code inventories — source-span extraction, passage reranking, claim checks.

Why: The honesty features are the value. It preserves citations (every extracted claim traces to a span) and preserves no-match outcomes — when the evidence isn't there, it says so instead of confabulating a best-effort quote. For code, exact lookup goes through required graph tools rather than fuzzy grep. Most extraction skills I evaluate fail precisely here: they always find something.

The one thing: Trigger quality is the lowest of the family at 6/10 — it overlaps conceptually with jev-eval, and the family's own docs spend effort disambiguating them. Expect to call it by name.

4. jev — 8.6/10

The hub: design Jev-assisted workflows from the collected use cases, references and examples.

Why: This is the meta-skill — you bring it a workflow problem ("I need to triage feedback, then verify claims against docs, then decide escalation") and it assembles a pattern from the scenario library, 108 documented examples with 14 recorded input/output pairs. Structure 9.3, content 9, engineering 10. As a piece of skill authoring — progressive disclosure, reference indexes, customization guides — it's among the best I've evaluated.

The one thing: Trigger quality 5.5/10, and honestly that's inherent: it's a design-time skill you invoke deliberately, not something that should fire on a keyword. Scored as-is, not punished for philosophy.

5. jev-act — 8.4/10

Chooses one legal next action in a browser, desktop, game or simulation, from fresh observed state and available actions.

Why: The action-selection primitive behind the repo's browser demos. The safety architecture is clean: the skill only selects — "selection does not grant permission" — and the host executes and checks results. One action per call forces a fresh-observation loop instead of blind macro playback.

The one thing: The family's most niche member. If you're not building a browser agent or simulator, skip it; if you are, note it wants clean observed-state inputs, not screenshots of screenshots.

How they compose

The family is a pipeline toolkit. A support operation might run: jev-triage sorts the inbox into queues → jev-documents pulls evidence from tickets and docs → jev-eval scores severity against your criteria → jev-act picks the next step inside your tooling. And jev is how you'd design that workflow in the first place, from the scenario library.

The security scores deserve one more line: 10/10 on all five members — the first family to do that in our evaluations. It's not a coincidence. The boundaries are designed in ("labels, not replies"; "not permission to merge"; "selection does not grant permission"), and the family never both decides and executes. That separation is exactly what agent-skill security should look like.

Scores at a glance

| Skill | Overall | Trigger | Structure | Workflow | Content | Engineering | Security |

|---|---|---|---|---|---|---|---|

| jev-triage | 9.2 | 7.5 | 10 | 9.6 | 9 | 9 | 10 |

| jev-eval | 9.1 | 7 | 9.3 | 9.6 | 9 | 10 | 10 |

| jev | 8.6 | 5.5 | 9.3 | 8.8 | 9 | 10 | 10 |

| jev-documents | 8.6 | 6 | 9.3 | 8.8 | 9 | 9 | 10 |

| jev-act | 8.4 | 5.5 | 9.3 | 8.4 | 9 | 9 | 10 |

The honest weak spot: trigger quality (5.5–7.5). These are primitives you call by name, not ambient helpers that fire on keywords. Treat that as a design choice — but if you want skills that auto-activate from conversation flow, this family isn't that.

Install

All five are one-line installs:

curl -fsSL https://skill123.me/install/jev-triage.sh | bash
curl -fsSL https://skill123.me/install/jev-eval.sh | bash
curl -fsSL https://skill123.me/install/jev-documents.sh | bash
curl -fsSL https://skill123.me/install/jev.sh | bash
curl -fsSL https://skill123.me/install/jev-act.sh | bash

Or give this to your AI assistant and let it install all five:

Install the following 5 skills by visiting each URL below and following its installation instructions:

- https://skill123.me/install/jev-triage
- https://skill123.me/install/jev-eval
- https://skill123.me/install/jev-documents
- https://skill123.me/install/jev
- https://skill123.me/install/jev-act

Start with jev-triage on a real backlog you already understand — that's the fastest way to see what a judgment primitive buys you over prompting from scratch.