⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v0.8.0

jev-use

shitianfang@shitianfang⭐ 72 stars· last commit 1mo ago· 1 open issues

Use before ANY step that is a decision rather than writing: labelling, filtering or triaging MANY items; checking whether a command, test or build succeeded; picking the next action from options you can list; judging safety, quality or severity; or risk-checking each command of a checklist or pipeline before it runs. Route by where the facts already are: facts already in your context go to the jev_judge tool with ALL questions batched into ONE call; items sitting in a file or in tool output go through the `jev-use judge` CLI from a script, so that data never enters the conversation; a safety decision that blocks every tool call belongs in the `jev-use hook gate` PreToolUse hook, not in a call you make by hand. Take any verdict back with escalate: true. Never for steps that must produce new text or code, or judgments whose options you cannot enumerate.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 72 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

jev-use

English | 简体中文

The best way for Claude Code, Codex, and pi to work with Jev: hand the tasks that need no text output to Jev — faster steps, fewer tokens, tasks done sooner and better.

It makes the LLM and Jev true collaborators: when content needs to be written, the LLM takes over; when a step just needs a fast decision, Jev executes it.

Demos — real runs, 1× speed

Every demo is a rerunnable script in bench/examples/; all numbers, methodology, variance and caveats: bench/RESULTS.md · third-party measurements: docs/evidence.md.

Install

npx -y jev-use install    # wires Claude Code, Codex, and pi — whichever it finds

Set one key in the environment your agent runs in (JEV_BACKEND=mock for a keyless dry run):

ProviderEnv var
TypeSafe directTYPESAFE_API_KEY
OpenRouterOPENROUTER_API_KEY
Vercel AI GatewayAI_GATEWAY_API_KEY

npx -y jev-use doctor checks the wiring. Judged state goes to the provider you configure; JEV_BACKEND=mock stays local. Plugin form with the routing skill and the PreToolUse gate: harness/claude-code · harness/codex.

Use as a library

npm i jev-use — zero runtime dependencies on the judgment path:

import { Jev, check, pick, rate } from "jev-use";

const jev = new Jev();

const { answers } = await jev.judge(state, {
  next: pick("Next action?", { merge: "all green", rerun: "looks flaky", hold: "needs attention" }),
  risk: rate("How risky?", ["routine", "worth a look", "incident"]),
  passed: check("Did the run fully succeed?"),
});
// answers.next → { answer: "merge", confidence: 0.93, confidenceFrom: "reported", escalate: false }

Anything Jev can't or shouldn't decide comes back with escalate: true and a typed reason. Tools, verdict shape, escalation contract, CLI: docs/reference.md.

Small enough to read

FileJob
src/protocol.tsQuestions (check/pick/rate), verdicts, escalation reasons
src/dispatch.tsPre-call routing: what never reaches Jev
src/judge.tsscreen → backend → hand back what is unsure; gate
src/jev.tsThe Jev client over that engine
src/redact.tsCredentials stripped from a gated action before it is sent
src/backends/TypeSafe, OpenRouter, Vercel, mock adapters
src/server.tsThe two MCP tools
src/cli.tsinstall, serve, hook gate, doctor
skills/jev-use/SKILL.mdThe routing rules the agent follows

Development

$ npm run typecheck && npm test    # unit tests incl. per-provider wire fixtures
$ npm run smoke                    # real MCP client ↔ built CLI over stdio
$ node bench/run.mjs               # micro-benchmarks, your key and region

Substantially written with Claude Code (AI-assisted).

MIT © shitianfang

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/jev-use/SKILL.md3.3 KB6a1ee8863882upstream ↗
    ---
    name: jev-use
    description: Use before ANY step that is a decision rather than writing: labelling, filtering or triaging MANY items; checking whether a command, test or build succeeded; picking the next action from options you can list; judging safety, quality or severity; or risk-checking each command of a checklist or pipeline before it runs. Route by where the facts already are: facts already in your context go to the jev_judge tool with ALL questions batched into ONE call; items sitting in a file or in tool output go through the `jev-use judge` CLI from a script, so that data never enters the conversation; a safety decision that blocks every tool call belongs in the `jev-use hook gate` PreToolUse hook, not in a call you make by hand. Take any verdict back with escalate: true. Never for steps that must produce new text or code, or judgments whose options you cannot enumerate.
    ---
    
    # Handing off to Jev
    
    Jev answers a typed judgment in ~250 ms at a judgment-model rate ($0.042/Mtok
    in, $0 out) instead of LLM reasoning. It is a RATE win, not a token win: Jev
    spends *more* tokens per decision, not fewer. So the saving is real only when
    the decision **leaves the conversation** — which is what the routing below is
    for. You stay the planner and the writer.
    
    ## Route each decision: where are the facts × does it block?
    
    | Where the facts are | **Nothing is blocked** — you can keep working | **Blocked** — nothing proceeds until this is decided |
    | --- | --- | --- |
    | **Already in your context** | `jev_judge`, every question about that state batched into **ONE** call (`noul` yes/no, `choice` next action, `score` quality) | `jev_gate` on that one action before you run it — and if it is *every* tool call, wire `jev-use hook gate` as a PreToolUse hook **once** and the decision leaves the conversation for good: 24 gated commands, 17.1 s, **zero LLM tokens**, vs 46.9 s / $0.2366 through a supervisor LLM |
    | **Sitting in a file or tool output** | a script pipes the file to `jev-use judge` — the items never enter your context | same CLI, from the script, then act on the verdicts it prints |
    | **To be written by you** (new text, code, options you cannot enumerate) | yours | yours |
    
    ## Rules that make it pay off
    
    - **Route bulk data by reference.** When the items sit in a file or in tool
      output, have a script pipe them to `jev-use judge` — data pasted into a
      `jev_judge` call travels through your context twice, as tool input and as
      the verdict block back. Or route only the handful you genuinely cannot
      settle yourself.
    - **Batch.** Measured: 12 questions about one state in ONE call took 224 ms;
      the same 12 one at a time took 2,662 ms. Never one call per item.
    - **State is everything Jev sees.** Put the relevant facts (tool output, file
      excerpts, task intent) into `state`; Jev has no other context.
    - **Honor escalations.** A verdict with `escalate: true` hands that question
      back to you: `writing`/`open_ended` mean it was structurally yours;
      `oversized` means the state was too big to judge; `unsure` means Jev's
      answer is only a prior (it's still in `answer` — use it as a hint);
      `unreachable` means proceed as if Jev didn't exist.
    - **Don't route trivia.** If you already know the answer, just act; a Jev
      call you didn't need is still a call.
    
    Numbers, lanes, variance and caveats: `bench/RESULTS.md`.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/shitianfang-jev-use-skills-jev-use.md

// REPO STATS

72 stars
1 open issues
Last commit: 1mo ago