Jev, from TypeSafe, is a decision model rather than a writer. It returns true or false, one choice from a list you supply, or a score, in a fraction of a second and at a tiny cost, so it can sit inside loops that would be too slow or too expensive with a language model.
Every one of the 19 builds follows the same shape: Claude builds the tool, and Jev makes the repeated small decision inside it. The decision may be a category, a tag, a confidence score, which skill or model to use, which paragraph, icon or page section fits.
The numbers on screen are the selling point: 217 call transcripts sorted in 13 seconds for 7 cents, 1,700 emails for 18 cents, 411 clips scored in 6.5 seconds, and the right Claude Code skill picked in 5.3 seconds where Opus 5 took 30.
Calibrate before you trust it. Run Jev against a set a person already labelled, measure the match rate (93 of 100 in Jay's demo) and study the misses, then route anything below a confidence threshold to a person.
The pattern is spreading beyond Jev: OpenAI has announced a Decisions API that picks one of your allowed answers in about 150 milliseconds, so learning to build with a picker model pays off whichever vendor wins.
Almost every prompt card ends the same way: connect to Jev through openrouter.ai. For background on how Jev works, see the library's earlier Jev playbooks: https://alexana-learning-library.vercel.app/p/wtf-is-jev-QbYBRjOaGOo/ and https://alexana-learning-library.vercel.app/p/jev-the-ultimate-classification-model-X117w2Rark8/
Jay presents Jev as a decision model from TypeSafe. It cannot write a sentence but picks true or false, a menu choice, or a score in a fraction of a second for almost nothing. He claims Jev is up to 200 times faster and 400 times cheaper than other models. The video gives 19 use cases, easy to advanced, each with a starter prompt.
Jev cannot write a sentence; it picks. The three answer shapes are true or false, one option from a menu (Groceries, Software, Travel, Other), and a score on a slider. Screenshot at 01:07.
Easy: point Jev at data you already have
The eight easy builds, in the order Jay shows them:
Fill a spreadsheet column from a fixed list in Google Sheets.
Triage customer inquiries and send low-confidence ones to a person.
Jay shows how to put Jev in Google Sheets. You type a new column header such as Category and Jev fills every row from an allowed list shown on screen: Groceries, Software, Travel, Eating out, Other. Because Jev can only pick from the list, it never invents a category you did not ask for.
A bank export after Jev fills the Category column: Eating out, Groceries, Software, Travel, Other, all from the allowed list. Screenshot at 01:20.The starter prompt for the Sheets add-on. Screenshot at 01:27.
Prompt shown on screen
Build me a Google Sheets add-on. When I type a new column header, like Category, send each row plus that header to Jev, and fill the column with its answers. Let me give it a list of allowed options, like Groceries, Software, Travel, Eating out and Other.
Connect to Jev via openrouter.ai if you don't have it yet.
Jev works as the decision layer for customer inquiries instead of a big model reading every message. It tags each inquiry as billing, bug, how-to, or other and includes a confidence score. Jay suggests a rule that sends anything below 60% confidence to a person, a threshold you can adjust. An independent test sorted 217 customer call transcripts in 13 seconds for 7 cents.
Each inquiry gets a category and a confidence score; hovering shows Jev's reasoning, here 95% sure it is a how-to question. Screenshot at 01:56.Messages Jev is unsure about are flagged Needs a person instead of going to an automation. Screenshot at 02:08.The starter prompt, shown over the independent test result: 13 seconds for 7 cents. Screenshot at 02:23.
Prompt shown on screen
Build me an automation for my customer inquiries. For each new message, ask Jev to pick the category (billing, bug, how-to or other) and how sure it is. Send the ones an automation can handle to the right workflow, and send anything Jev is less than 60% sure about to a person. Make the 60% easy to change.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay explains using the Meta Ad Library to see competitor ads. A Claude-built plugin or Chrome extension saves each ad, and Jev reads the text to tag format, call to action, and funnel stage. All results land in a database as a swipe file. Jay's test tagged 54 ads from three brands in about 1.5 seconds for under a cent.
Everything lands in a database: format, call to action and funnel stage for each ad, a ready swipe file. Screenshot at 02:56.Jay's run over the Ad Library: tagged in about 1.5 seconds for less than a cent. Screenshot at 03:06.
No prompt card appears on screen for this one; Jay points to the free PDF guide linked under the video for it.
Jay built a clip finder that scores possible clips from long videos or podcasts. His test scored 411 possible clips from a 70-minute interview in 6.5 seconds. Jev then picked the top 10 clips worth posting. The on-screen example uses a Sam Altman talk from How to Start a Startup, with clips scored out of 100.
The finished run: 411 of 411 candidate clips scored in 6.5 seconds. Screenshot at 03:25.The shortlist Jev hands back, each clip scored out of 100 with its timestamp. Screenshot at 03:26.The starter prompt for the clip finder. Screenshot at 03:33.
Prompt shown on screen
Transcribe my video, [episode.mp4], with word timings. Cut it into possible 30 to 60 second clips, use Jev to score each one for how well it would work as a short, and give me the top 10 with start and end times.
Connect to Jev via openrouter.ai if you don't have it yet.
For a SaaS business, Jay describes scoring the customer base from existing data. Jev reads customer tenure, annual plan, and cancellation signals, then groups customers as healthy, needs attention, or at risk of churn. This lets you know who to contact this week instead of finding out when someone cancels.
A Churn risk column filled by Jev from tenure, last login and status: Healthy, Needs attention or At risk. Screenshot at 03:52.
No prompt card appears on screen for this one; Jay points to the free PDF guide linked under the video for it.
Jev picks which pages should link to each other in a large site or a second brain, a big folder of notes agents work in. Jay tested this on 60 test blog posts, and it took about two and a half seconds to place 206 links. On screen, Jev Links shows 60 of 60 pages read, 206 links placed, 2.54 seconds, and $0.0381.
The backlink run on 60 test blog posts: 206 links placed and 274 rejected in 2.54 seconds for $0.0381. Screenshot at 04:24.The starter prompt, which runs the same pass over the site and then over a notes vault. Screenshot at 04:34.
Prompt shown on screen
Read every page on my site [from its sitemap]. For each page, use Jev to pick which other pages it should link to, and on which phrase. Give me the list of links to add, best first. Then do the same for the notes in my [Obsidian vault or second brain folder].
Connect to Jev via openrouter.ai if you don't have it yet.
Jay explains pulling TikTok comments with Apify, a scraping tool. Jev tags each comment as ready to buy, question, complaint, or other. You then get a priority list with ready-to-buy people at the top, so you do not have to manually scroll through comments.
Comments pulled from a seller's TikTok, each tagged Ready to buy, Question, Complaint or Other. Screenshot at 04:56.The starter prompt, which uses Apify for the scraping. Screenshot at 05:03.
Prompt shown on screen
Use Apify to pull the latest 500 comments from the TikTok account @tonylcsign. Use Jev to tag each comment as Ready to buy, Question, Complaint or Other. Give me a list with the Ready to buy comments at the top, with a link to each one.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay teaches how to verify Jev's categorization with a validation set. You run Jev on a few dozen to a hundred examples a person already sorted, without showing the answers, then count matches. You study the misses to calibrate the model. On screen, matches are 93 of 100, with 7 rows where Jev and the person disagree.
Jev's labels next to a person's labels: 93 of 100 match. Screenshot at 05:32.The seven disagreements, which are where calibration starts. Screenshot at 05:34.The starter prompt, which holds back half the labelled set so the score is honest. Screenshot at 05:36.
Prompt shown on screen
I have [labelled.csv] with about 200 examples that a person already sorted into categories. Split them in half: use the first half to tweak my categories and instructions, and report scores only on the second half. Run each one through Jev, add Jev's answer and its confidence next to the person's label, then show me how often they match, where they disagree most, and how accurate Jev is at each confidence level.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay summarizes the easy tier as pointing Jev at a pile of stuff you already have and letting it categorize at lightning speed. The pattern is simple: existing data goes in, Jev classifies it, and you save time and money.
Intermediate: let Jev make decisions inside your tools
Jay applies Jev to picking the right skill in Claude Code. With dozens of skills, Claude can be slow to load the correct one, so the skills become Jev's menu. Jay has about 145 skills and across 14 tests Jev found the right skills in about 5 seconds total while Opus 5 took around 30. TypeSafe tested 182 skills and cut wrong picks by more than half.
Across the test tasks Jev picked the right skill in 5.3 seconds; Opus 5 reading the full list took 30.0 seconds. Screenshot at 06:51.TypeSafe's own test: two requests per turn, one to rank skills and one to verify the choice, cut wrong skill loads by more than half. The starter prompt sits below it. Screenshot at 06:55.
Prompt shown on screen
Before you load a skill, send my task and the list of my skill names and descriptions to Jev as a choice question, and load the skill it picks. Add a None option, and test it on 10 of my past tasks.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay uses a /jev on command to route messages to the right model. Jev reads every message and chooses the model in about a third of a second. A file-path task went to a Haiku helper, while a data-model design task went to Opus. This routing idea works in Codex and other agentic platforms.
A simple task, finding a file path, goes to a Haiku helper: confidence 0.99, decided in 352 ms. Screenshot at 07:20.A hard task, designing a data model, goes to Opus: confidence 0.85, decided in 552 ms. Screenshot at 07:24.The starter prompt; the same routing works in Codex and other agent tools. Screenshot at 07:29.
Prompt shown on screen
Make me a /jev on command. While it's on, send each message I type to Jev first, ask how hard the task is, and hand it to a Haiku, Sonnet or Opus helper agent to match. Log every pick.
Connect to Jev via openrouter.ai if you don't have it yet.
Jev sits in front of an email agent so the big model does not read every email including spam. In one test, Jev sorted 1,700 emails for 18 cents, tagging needs a reply, brand deal, scam, or spam. Only emails that need a reply go to Claude, reducing reads and token costs.
In one test Jev sorted 1,700 emails for 18 cents, and only the ones needing a reply went on to Claude. Screenshot at 07:52.The starter prompt for the email gate. Screenshot at 08:01.
Prompt shown on screen
Before my email agent drafts anything, send each new email to Jev with three questions: does it need a reply, is it a brand deal, is it a scam? Only pass the ones that need a reply to Claude to draft.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay shows Chrome extensions built with Jev. One example checks every X post as it loads and answers the question of whether it is AI slop. If yes, the post folds away. The same trick works on LinkedIn or any feed. Another example hides ads and cookie banners like the Unclutter extension.
A feed cleaner on X: each post is checked as it loads and AI slop is folded away. Screenshot at 08:16.Unclutter, an open-source extension that strips ads and cookie banners, as another example of the same idea. Screenshot at 08:32.The starter prompt for the slop filter. Screenshot at 08:35.
Prompt shown on screen
Build me a Chrome extension for X. As each post loads, ask Jev if it's AI slop, true or false, and fold the post away if Jev is over 80% sure. Add a small button to show it anyway.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay explains search by meaning, different from Ctrl+F which finds exact words. Jev splits a page into paragraphs, picks the best match, and scrolls to it, fast enough to feel real time. On screen, the query getting my money back highlights the refund paragraph.
The query "getting my money back" lands on the refund paragraph even though those words never appear in it. Screenshot at 08:53.The starter prompt for a meaning-based Ctrl+F. Screenshot at 09:05.
Prompt shown on screen
Build me a Chrome extension that replaces Ctrl F. I type what I mean, it splits the page into paragraphs, asks Jev which one matches best, then scrolls to it and highlights it.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay searches generated images by what is in them, not file names, using each image's saved prompt as metadata. For images missing metadata, a small cheap model like Gemini Flash-Lite can caption them, about 50 cents for 1,000 images. On screen, Jev search returns 109 results in 780 ms for $0.0034.
A Jev search over Jay's generated images: 109 results for "Claude" in 780 ms for $0.0034. Screenshot at 09:22.Captioning images that lack metadata with Gemini Flash-Lite costs about 50 cents per 1,000. The starter prompt sits below. Screenshot at 09:48.
Prompt shown on screen
Index my images folder. For each image, use its saved prompt, or ask Gemini Flash-Lite for a one-line caption if it has none. Then build a search box where Jev picks the images that match what I type.
Connect to Jev via openrouter.ai if you don't have it yet.
Advanced: decisions in real time
The five advanced builds
Check what people say while they are saying it.
Answer questions from a fixed dataset with no language model call.
Pick icons in an app as the user types.
Assemble a web page from ready-made parts for each visitor.
Because Jev answers in a fraction of a second, it can check what people say while they say it. Someone built JevMeter, a live BS meter that scores every sentence of a debate. A meeting plugin can sort each sentence into decisions, action items, risks, and questions, useful on sales calls, interviews, and podcasts.
Sentences are checked as they are spoken. Screenshot at 10:04.During a meeting each sentence lands under its heading, here Questions and Updates, in about a quarter of a second. Screenshot at 10:16.The starter prompt for the meeting sorter. Screenshot at 10:29.
Prompt shown on screen
Build a page that listens to my meeting through the mic and transcribes it live. After every sentence, ask Jev if it's a decision, an action item, a risk or a question, and show it under that heading.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay demonstrates a chatbot with zero LLM calls. The demo app answers which lesson teaches a topic by having Jev pick from a list of pre-transcribed videos and their chapters. On screen, the answer points to a minute in a video with 0 LLM calls. This fits narrow chatbots over a fixed dataset like transcripts or company documents.
The answer is a pointer into a video at 3:00, chosen by Jev with zero language-model calls. Screenshot at 10:48.The starter prompt for a narrow chatbot over video transcripts. Screenshot at 11:06.
Prompt shown on screen
Here are my video transcripts. Build a chat box where a member asks a question, and Jev picks the best video and the minute from my list of chapters. Show that video and time, with no LLM writing the answer.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay shows Jev picking from a fixed set of icons as the user types. In a habit tracker, typing drink more water picks the water icon; a mood app picks a mood icon. A designer showed icons appearing as he typed. Before Jev, this needed a costlier LLM or a regex-based matching system that works less well.
In a habit tracker, typing "Drink more water" selects the water icon. Screenshot at 11:24.A designer's demo pulling matching icons as he types. Screenshot at 11:32.
No prompt card appears on screen for this one; Jay points to the free PDF guide linked under the video for it.
Jay explains pages that build themselves. Jev cannot write code but can pick parts from a library of ready-made pieces like forms, buttons, sign-in boxes, and fonts. Jev decides what each visitor needs and assembles the page on the fly, about as fast as a normal page load.
A default page beside the version Jev assembled for one visitor; it loads about as fast as a normal page. Screenshot at 12:16.The starter prompt for a self-building landing page. Screenshot at 12:23.
Prompt shown on screen
Build me a landing page that builds itself. I have sections for hero, pricing, sign-in and testimonials. When someone lands, send what we know about them to Jev, let it pick four sections, and show them in that order.
Connect to Jev via openrouter.ai if you don't have it yet.
Jay suggests using Jev to find your own use cases. The site shipwithjev.com lists Jev use cases by category, with 620 use cases shown on screen. You can paste the site and a file about yourself into Claude and ask which would help most. Alternatively, ask Claude to review past sessions and point out steps where a quick Jev call would have done the job.
shipwithjev.com, a catalogue of Jev builds by category. Screenshot at 12:34.Paste the site and a file about yourself, then ask which builds fit. Screenshot at 12:46.Claude uses Jev to rank the candidates for you. Screenshot at 12:52.
Prompt shown on screen
Based on everything you know about me, which five Jev builds would help me most?
The second route: mine your own past sessions. Screenshot at 12:58.The result is a list of steps in work you already do where a Jev call would have been enough. Screenshot at 13:00.
Prompt shown on screen
Look back over my last 20 sessions and list the steps where a quick Jev call would have done the job.
Jay notes that OpenAI launched a Decisions API at Dev Day. You give it a question and a list of allowed answers and it picks one in about 150 milliseconds. Jay calls this OpenAI's answer to Jev. His point is to learn this decision-model way of building even without Jev, because other labs, Anthropic likely included, will copy it.
OpenAI's Decisions API, announced at Dev Day and built on its small Luna model. Screenshot at 13:12.Give it a question and the allowed answers, and it picks one, here Support, in about 150 ms. Screenshot at 13:21.
Tools and resources
Item
What it is
Notes
Jev
TypeSafe's decision model
Returns true or false, one choice from your list, or a score; on OpenRouter as typesafe/jev
TypeSafe
The company behind Jev
Its cookbook claims a two-request skill picker cuts wrong skill loads by more than half (182-skill test)
OpenRouter
Model gateway
Every prompt card says to connect to Jev through openrouter.ai
Claude and Claude Code
The builder in every use case
Claude writes the tool; Jev makes the repeated decision inside it
Google Sheets
Spreadsheet
Host for the column-fill add-on
Meta Ad Library
Public library of running ads
Source for the competitor swipe file
Apify
Scraping platform
Pulls TikTok comments in the buyers build
Gemini Flash-Lite
Small, cheap Google model
Writes one-line image captions where no saved prompt exists, about 50 cents per 1,000 images
JevMeter
Third-party live debate scorer
Scores each spoken sentence
Unclutter
Open-source Chrome extension
Strips ads, cookie banners and similar clutter
shipwithjev.com
Catalogue of Jev builds
620 use cases by category at recording time
OpenAI Decisions API
OpenAI's picker endpoint
Announced at Dev Day; question plus allowed answers, about 150 ms; pricing not stated
Free PDF guide
Jay's write-up of all 19 prompts
Linked under the video; it also holds the prompts for the builds with no on-screen card
Claims to verify
"Up to 200 times faster and 400 times cheaper than other models" is the vendor's headline range, not a measurement from this video.
The 217-transcript test (13 seconds, 7 cents) is described as independent but not named; treat it as reported.
Jay's own timings (54 ads in about 1.5 seconds, 411 clips in 6.5 seconds, 60 pages in 2.54 seconds, skills in 5.3 seconds against 30.0 for Opus 5) are single runs on his setup.
TypeSafe's "more than half fewer wrong skill loads" comes from TypeSafe's own cookbook test with 182 skills.
The 1,700 emails for 18 cents figure is from a test Jay cites without naming the source.
OpenAI's Decisions API was described as just launched with pricing unknown; check availability and price before planning around it.
Glossary
decision model: A model that picks an answer (true or false, one option from a list, or a score) instead of generating text.
Jev: TypeSafe's decision model, used here as the fast picker inside Claude-built tools.
TypeSafe: The company that makes Jev.
confidence score: How sure Jev is about its pick, used to send uncertain cases to a person.
confidence threshold: The cutoff below which an answer is routed to a human instead of an automation.
triage: Sorting incoming items into categories so each goes to the right place.
validation set: Examples a person already labelled, used to measure how often the model agrees.
calibration: Adjusting categories and instructions until the model's confidence matches how often it is right.
swipe file: A collection of examples, here competitor ads, kept for reference.
funnel stage: Where an ad sits in the buying journey, such as awareness, consideration or conversion.
churn: Customers cancelling or leaving a subscription.
backlinks: Links from one page or note to another related one.
second brain: A large folder of notes that a person and their agents work in, such as an Obsidian vault.
Apify: A scraping platform that pulls public data such as social comments.
skill: A packaged set of instructions Claude Code can load for a task.
model routing: Sending each request to the cheapest model that can handle it.
Haiku: Anthropic's smallest and cheapest Claude model.
Opus: Anthropic's largest Claude model.
AI slop: Low-effort, AI-generated posts that clutter a feed.
metadata: Written words about an item, such as an image's prompt or caption, that make it searchable.
search by meaning: Finding the passage that matches what you mean even when the words differ.
regex: A pattern-matching language for text; brittle for fuzzy matching.
LLM: Large language model, a model that writes text.
OpenRouter: A gateway that serves many AI models through one API.
Decisions API: OpenAI's endpoint that picks one of a list of allowed answers.
Personal recommendations
1
Route Claude Code skills with Jev instead of pattern matching
With about 145 skills, Jev picked the right one in 5.3 seconds against 30.0 for Opus 5, and TypeSafe reports more than half fewer wrong skill loads when a second request verifies the pick.
System value
The matt-skills-router UserPromptSubmit hook suggests skills by pattern-matching the prompt. A Jev choice question over skill names and descriptions, with a None option, could pick the right skill from intent rather than wording, tested first against labelled past prompts.
Proposed form
Prototype in the hook, run in shadow beside the pattern router with a validation set of past prompts.
Target project
alexana-workspace (Claude Code tooling).
2
Mine past sessions for steps a Jev call could have done
Jay asks Claude to look back over the last 20 sessions and list the steps where a quick Jev call would have done the job.
System value
Fleet already runs Jev decision-shadows; a periodic sweep of session transcripts would surface new shadow candidates from real work instead of guesses.
Proposed form
Recurring research task that writes a ranked candidate list into the fleet's shadow-candidate backlog.
Target project
alexana-workspace (fleet-control).
3
Let Jev propose cross-links for orphaned vault docs
Jev placed 206 links across 60 pages in 2.54 seconds for $0.0381, and the same pass runs over a notes vault.
System value
The nightly spider already flags orphaned artifacts with no inbound breadcrumb. Jev could pick the best existing doc and phrase to point at each one, turning a finding into a ready one-line breadcrumb proposal.
Proposed form
A new proposal producer in the spider's preflight lane, report-only until reviewed.
Target project
alexana-workspace (vault-audit).
4
Add a zero-LLM "which playbook covers this" box to the Learning Library
A chatbot answers which lesson teaches a topic by having Jev pick a video and minute from a chapter list, with no language model writing the answer.
System value
The library holds dozens of playbooks with timestamped chapters. A search box where Jev picks the playbook and section would make the hub useful as a reference on mobile, cheaply and fast.
Proposed form
Build in the learning-library repo, using INDEX descriptions and chapter headings as the menu.
Target project
learning.
5
Surface ready-to-buy comments on listing videos for NEXT agents
Comments pulled with Apify are tagged Ready to buy, Question, Complaint or Other, with buyers listed first.
System value
NEXT agents post listing videos; tagging comments for buying or showing intent would hand them a short follow-up list instead of scrolling.
Proposed form
Prototype on one agent's account, then decide whether it belongs in NextTools.
Target project
next-real-estate.
Take this with you
Save the playbook to read later, or hand the raw notes to your favorite AI.
What's this?
The Markdown file (a .md file) is a plain-text copy of this whole playbook, written in the simple format AI chat tools read best. It keeps the headings, links, timestamps, and captions and drops all the page styling. Think of it as the raw notes behind this page, ready to hand to an assistant.
To use it, download the file and drag it into ChatGPT, Claude, or any AI chat (or just paste the text in), then ask for what you want: “Summarize this into a one-page cheat sheet,” “Turn these steps into a checklist I can follow,” or “Quiz me on the key ideas.” Because the file is already structured, the assistant works from the real content instead of guessing.
