README.md
September 17, 2026 · View on GitHub
Find where Jev belongs. Design the questions. Measure the difference.
A reusable agent skill for any app, codebase, or idea.
Get started · Community examples · Question design · Read the skill
Why Jevify?
Many LLM calls end with a tiny decision: choose a tool, keep a passage, flag a defect, rank a candidate. TypeSafe Jev makes those decisions through typed questions and probabilities, without generating a prose answer.
The opportunity is doing useful work more often, across more candidates, with less waiting and lower cost. An LLM can do many of the same tasks. Jevify helps you find where Jev's economics change what is practical, then design an honest comparison.
It combines current TypeSafe documentation, recent first-hand community experiments, and your application to produce concrete question packs and integration ideas. It works with an existing repository or a plain-language description.
Jevify is an independent skill from the ThursdAI community. It is not the Jev model, an API client, or an official TypeSafe product.
Get started
Install with the open agent skills CLI:
npx skills add altryne/jevify --skill jevify
The CLI asks which agents to install for (Claude Code, Codex, Cursor, and others) and whether to install for this project or globally. Common variations:
# Skip the prompts: install globally for Claude Code
npx skills add altryne/jevify --skill jevify -g -a claude-code -y
# See what the repository offers before installing
npx skills add altryne/jevify --list
# Later: check what is installed, pull the latest version, or uninstall
npx skills list
npx skills update
npx skills remove jevify
| Flag | Meaning |
|---|---|
-g, --global | Install to your user directory so every project can use it, instead of the current project only |
-a, --agent <name> | Target specific agents, for example claude-code, codex, or cursor |
-y, --yes | Skip confirmation prompts |
--copy | Copy the files instead of symlinking them |
npx comes with Node.js. Start a new agent session after installing so the skill is picked up. Pairing it with TypeSafe's own skill (npx skills add typesafe-ai/skills) works well: that one covers API and SDK basics, and Jevify adds discovery, question packs and evaluation.
No CLI? Give an agent this repository and ask it to read SKILL.md and its linked references.
Then ask:
Jevify this codebase. Find repeated LLM judgments or fragile semantic
heuristics that could benefit from Jev. Recommend the best opportunities,
write the actual questions, and propose a fair latency/cost/quality test.
No repository? Start with an idea:
Use Jevify to design a memory selector for my assistant. Several memories
can be useful at once. Show the state, primitives, exact questions,
batching strategy, fallback behavior, and evaluation cases.
Or improve an existing design:
Use Jevify to review these questions. Are the primitives right?
Rewrite ambiguous criteria, identify missing context, and show
which questions can run together.
Requirements: an agent that can read skill files and browse public docs. last30days is recommended for community research; the skill discloses when it falls back to public search. You need TypeSafe API access only when you choose to run inference. Installing the skill does not make API calls.
What you get
| Deliverable | What's inside |
|---|---|
| Opportunity map | Where Jev, a hybrid, a generative model, or existing code fits best |
| Question pack | Exact state, instructions, criteria, primitive choices, and missing-data behavior |
| Composition plan | Shared-state batching, dependent stages, routing, source extraction, and fallback |
| Evidence | Original sources and dates, with measured results separated from demos and proposals |
| Smallest useful experiment | Boundary cases and a fair test of latency, total cost, quality, and coverage |
What people are building
A few discoveries from September 14–17, 2026. These are examples of people using Jev, not claims that they used this skill. Results below are reported by the authors and were not reproduced here.
| Use case | Community example | Lesson for your app |
|---|---|---|
| Writing checks while you work | Mike Taylor / Every reported 777 judgments across 37 documents in under 0.7 seconds. | Turn a rubric into separate checks; let the writing model revise flagged passages. |
| Better agent memory selection | Aera's offline study tested Jev on 400 cases and found benefits from per-candidate judgments. | If several memories can help, ask a Noul for each rather than forcing one Choice winner. |
| Routing to the right model | Taishi Morinaga / DevelopersIO tested four difficulty tiers through Jev's Choice primitive. | Make routing a bounded decision; test borderline requests, not only obvious ones. |
| Home Assistant questions as entities | AboveColin / HA-Jev connects household state to probabilities, choices, and scores. | Compute exact sensor comparisons in code; send meaningful context for the semantic judgment. |
| Context-aware credential triage | teyhouse / jev-secret-detection evaluates synthetic credential and non-credential snippets. | Test false positives by category. A semantic check complements established scanners. |
| Interactive idea scoring | A community builder's demo evaluates ideas across roughly ten parallel criteria. | Score distinct dimensions, then expose the weights and tradeoffs in code. |
Speed is only half the story. Every's small writing comparison found a missed defect; Aera's wider candidate pools could cost more. Different task sizes and reasoning settings change the comparison. The full research notes preserve methods, numbers, caveats, and sources.
The skill refreshes community research for new discovery work, so this snapshot is a starting point rather than a frozen list of possibilities.
Three primitives, many possibilities
| Primitive | Ask | Use it for |
|---|---|---|
| Choice | “Which one?” | A handler, category, action, or source span |
| Noul | “Is this condition true?” | A defect, relevance check, or one of several applicable labels |
| Score | “How much, on this defined scale?” | Utility, severity, complexity, or another graded property |
A good question defines the decision boundary. “Is this good?” tells the model very little. “Does this passage supply a step or prerequisite needed to answer the query?” gives it a job.
Example: keep every useful passage
One request, shared context, independent judgments. Both passages may be useful, so this uses two Nouls rather than a single Choice.
{
"model": "jev-1.13.0",
"state": {
"query": "How do I rotate an API key without downtime?",
"passages": {
"a": "Create a second key, migrate clients, then revoke the old key.",
"b": "The service supports two active keys per project."
}
},
"questions": {
"keep_a": {
"type": "noul",
"instructions": "Does `passages.a` help answer `query` with a step, prerequisite, or constraint?"
},
"keep_b": {
"type": "noul",
"instructions": "Does `passages.b` help answer `query` with a step, prerequisite, or constraint?"
}
}
}
This is an illustrative native TypeSafe request body, not a recorded model result. Code applies a threshold validated on your data, keeps qualifying passages, and enforces the context budget. Question IDs are for your code; the target must also appear in the instructions, as a backticked state path. Check the current model and API contract before running.
Explore three complete request examples, nine boundary cases, a complete worked question pack, and the question-design guide.
Have an API key? Check the shapes for free, then run the examples:
python scripts/run_cases.py --dry-run
TYPESAFE_API_KEY=... python scripts/run_cases.py
A live run bills your TypeSafe account and sends the request state to TypeSafe.
How it works
flowchart LR
D[Official docs] --> R[Research]
C[Recent community experiments] --> R
A[Your app or idea] --> O[Find opportunities]
R --> O
O --> Q[Design typed questions]
Q --> B[Batch and compose in code]
B --> E[Evaluate against your baseline]
Jevify explores routing, retrieval, extraction, verification, document structure, entity matching, interactive decisions, and combinations of those patterns. It preserves exact calculations and hard rules in code, and keeps generative models where writing or deeper reasoning is needed.
Inside the skill
| File | Purpose |
|---|---|
| SKILL.md | The workflow your agent follows |
| Question design | Primitive selection, bad-to-better questions, batching, and pitfalls |
| Patterns | Compositions and links to official cookbooks |
| Research protocol | Refresh official docs and recent community evidence, widening the window when it is quiet |
| Community discoveries | Dated snapshots of first-hand experiments and transferable lessons |
| Worked question pack | One complete deliverable, from decision to composition code and thresholds |
| Product evidence | Documented interface, response shape, context window, weaknesses, pricing, and source links |
| Evaluation | Compare matched workloads, quality, latency, and total cost |
| Examples · Cases | Ready-to-adapt requests and evaluation seeds |
| run_cases.py | Validate request bodies, then send them and print answers, tokens, and cost |
| evals/ | Test prompts for checking changes to the skill itself |
From ThursdAI
Built by Alex Volkov, from the conversations and experiments around ThursdAI: the weekly AI show, podcast, and newsletter.
Contribute a discovery
Tried something useful with Jev? Open an issue or a PR with the original source, date, question shape, workload, result, and what failed. Reproducible experiments and better question designs are especially welcome. Use synthetic or public examples.
Maintaining the skill. Keep it portable: no install paths, private project paths, tickets, credentials, transcripts, or one project's rules inside the skill folder. Add new research as a dated snapshot at the top of community-discoveries.md and keep each snapshot small. When the TypeSafe docs change, update the verified date and facts in product-evidence.md, including the price and limits in scripts/run_cases.py. Run the prompts in evals/evals.json before and after a change; TypeSafe's own typesafe-ai skill is the fair baseline to compare against.
Thanks to TypeSafe for the model and documentation, last30days for community research, and the builders sharing their experiments.
MIT licensed. Third-party findings remain attributed to their authors.