Big Idea

The argument in one line.

Jev answers with a score, a category, or a true/false call instead of a paragraph, which makes it up to 200 times faster than a normal LLM and opens up an entirely new class of software.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You're building software features that need a fast yes/no, a ranking, or a category pick and currently reach for a full LLM call to get it.
You already ship AI features with Claude Code or a similar coding agent and want a concrete prompt for auditing where a faster model fits.
You're curious what a non-text-generating AI model actually does differently from ChatGPT or Claude, beyond the marketing claims.

SKIP IF…

You're looking for a hands-on API tutorial on prompting Jev directly; this is a conceptual overview plus one drop-in prompt, not a walkthrough of the SDK.
You want benchmark proof Jev outperforms other models; the video is demo-driven, not benchmarked.

TL;DR

The full version, fast.

Jev is a new model from Typesafe AI that doesn't generate text: instead of writing a paragraph, it answers a question with a category, a score, or a true/false call, which the creator says makes it up to 200 times faster than a normal LLM. He walks through demos, a color-percentage classifier, instant generative UI, a fuzzy-search launcher, live canvas control, and a tweet-virality scorer, then distills Jev's use to three jobs: categorization, scoring, and true/false judgment. He closes with a ready-to-paste prompt that has Claude Code audit your own project for a place Jev could replace a slow LLM call with a fast, defined decision.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:44

01 · The hook: Jev claims to change software

Chris opens claiming the new model Jev, from Typesafe AI, will change software forever, and previews the video's three-part structure.

00:44 – 01:13

02 · What this video covers

Agenda slide: what Jev is and how it works, incredible use cases for it, and how to add it to your own projects.

01:13 – 03:36

03 · What Jev is, and why it's not a normal LLM

Traditional LLMs output a string of text to answer a question; Jev instead scores or classifies against fixed categories. Trained with RLCD instead of RLHF, and claimed to run up to 200x faster.

03:36 – 05:41

04 · Live comparison: text answers vs instant scores

The invoice-fraud example: an LLM takes 8.5 seconds to write out a fraud explanation, while Jev returns a clean/fraud/review score almost instantly. Jev can pick an action, classify, score, or route.

05:41 – 07:14

05 · Use case reel: color scoring, generative UI, fuzzy search

A word-to-color-percentage classifier, an instant generative UI demo from Chris Tate, and a fuzzy-search Mac launcher from Nader at Cognition that ranks matches by intent almost instantly.

07:14 – 08:17

06 · More demos: canvas control and a virality scorer

Typing 'make a blue square' into a tldraw canvas renders the shape instantly; a Tweet Tester tool scores a draft tweet's viral potential and suggests post, rewrite, or stop.

08:17 – 09:07

07 · Recap: the three things Jev is great at

Every demo collapses into three jobs: categorization against defined categories, scoring against defined levels and criteria, and true/false against defined parameters.

09:07 – 09:52

08 · The drop-in prompt to find your own use case

Chris reveals the exact prompt he uses to have an AI coding agent read a project's code and docs and propose up to three places Jev could fit.

09:52 – 14:20

09 · Live demo: running the prompt in Claude Code on Eyedropper

Chris pastes the prompt into Claude Code inside Eyedropper, his own cloud design-system tool. Claude Code proposes three use cases: qualitative rule checks in Verify, filtering false-positive color violations, and scoring extraction quality.

14:20 – 15:41

10 · Why this matters, and how to get access

Chris argues most of Jev's impact will be invisible to end users but will let smaller teams rebuild software faster, then points to Typesafe AI's signup/Discord and his own communities.

Atomic Insights

Lines worth screenshotting.

Jev, a new model from Typesafe AI, answers with a category, score, or true/false call instead of generating text, and does it up to 200 times faster than a standard LLM.
Jev is trained with RLCD (reinforcement learning from calibrated decisions) instead of RLHF, which optimizes it for consistent judgments rather than human-preferred prose.
Where a traditional LLM took 8.5 seconds to explain whether an invoice looked fraudulent, the same call framed as a fixed set of categories came back from Jev almost instantly.
Jev is good for exactly three jobs: picking a category from a defined set, scoring something against defined criteria, and answering true or false against defined parameters.
A generative UI demo rendered a full custom interface in milliseconds using Jev, instead of the multi-step JSON-render pipeline a traditional LLM needs to build the same screen.
A fuzzy-search desktop app used Jev to rank likely matches by intent almost instantly, functioning like a keystroke-level predictive launcher.
In a canvas-control demo, typing 'make a blue square' rendered the shape immediately, faster than the same command routed through computer use or an MCP-connected traditional LLM.
A virality-scoring tool used Jev to rate a draft tweet and suggest whether to post, rewrite, or stop, treating the decision as a defined-criteria score rather than free-form advice.
The creator's own drop-in prompt has an AI coding agent read a project's code and docs, then propose up to three places Jev could replace a slow LLM call with a fast, defined decision.
Because Jev only handles fixed categories, scores, and true/false calls, it isn't a replacement for LLMs that write or reason in open-ended language, it's a narrow, much faster tool for a narrow job.

Takeaway

Jev skips text and answers in scores, categories, and true/false calls.

WHAT TO LEARN

A model built to only categorize, score, or answer true/false can run up to 200 times faster than a text-generating LLM, and finding where that narrow shape fits is more valuable than the model itself.

03What Jev is, and why it's not a normal LLM

A model can be built to answer only in fixed categories, scores, or true/false calls instead of open text, and that constraint is what makes it fast.
Training method matters: RLCD calibrates a model for consistent judgments, while RLHF optimizes for text a human rates as good, which is a different objective.
Speed claims like '100-200x faster' come from skipping token-by-token text generation entirely, not from a bigger or better-tuned version of the same architecture.

04Live comparison: text answers vs instant scores

The same question (is this invoice fraud?) took 8.5 seconds as a written LLM explanation but came back near-instantly as a category and confidence score.
A true/false determination is a distinct capability from scoring or classifying, useful specifically for systems with a fixed, defined set of possible actions.
Jev can do four things: pick an action, classify against fixed criteria, score against defined levels, or route to a different option.

05Use case reel: color scoring, generative UI, fuzzy search

A word-to-color-percentage classifier is a good stress test for a categorical model: it has to map open vocabulary onto a bounded set of outputs, fast.
Generative UI rendered in milliseconds only works because the model is choosing from a defined component/design-system palette, not writing new UI code from scratch each time.
A fuzzy-search launcher ranked likely matches by intent from partial keystrokes almost instantly, because ranking a fixed candidate set is exactly what a scoring model is built for.

06More demos: canvas control and a virality scorer

Voice/text canvas control ('make a blue square') rendered faster than the same command routed through computer use or an MCP-connected traditional LLM, because it's a bounded action, not a generated explanation.
A tweet-virality tool scored a draft against defined criteria and told the user to post, rewrite, or stop, turning subjective judgment into a repeatable score.

07Recap: the three things Jev is great at

The creator collapses every demo into three jobs: categorization against defined categories, scoring against defined levels and criteria, and true/false against defined parameters.
If a decision doesn't fit one of those three shapes, a model built this way isn't the right tool for it.

08The drop-in prompt to find your own use case

The recommended way to find a use case is to have an AI coding agent read your own project's code and docs first, not to brainstorm generically.
A good use-case prompt asks for the problem solved, the exact question asked, how the answer would be used, and what happens if the answer is wrong or unavailable.

09Live demo: running the prompt in Claude Code on Eyedropper

The first real use case that surfaced was upgrading a design-system checker from comparing colors/fonts/sizes to enforcing qualitative rules like 'never place two primary buttons in one view.'
The second was filtering false-positive violations, catching that colors inside SVG paths get flagged, when a scoring pass could tell a real violation from a legitimate exception.
The third was scoring the quality of an AI's own design-system extraction, so a bad extraction below a defined quality bar triggers one automatic corrective re-run instead of shipping bad rules.
Prefer small changes to existing features; don't add AI where ordinary code already handles the decision reliably, and don't assume a confident answer is a correct one.

10Why this matters, and how to get access

The claim is that most of the impact will be invisible: software will just work better and faster, and users won't consciously notice the model behind it.
The bigger implication offered is that faster, cheaper structured decisions let much smaller teams rebuild and rewrite categories of software that used to require larger teams.

Glossary

Terms worth knowing.

Jev: A new AI model from Typesafe AI built to make fast, structured decisions, categorizing, scoring, or answering true/false, instead of generating open-ended text.
Typesafe AI: The company behind Jev, positioned as the maker of the first public 'System One' model.
RLCD (reinforcement learning from calibrated decisions): The training method behind Jev; it calibrates the model to give consistent scores and classifications rather than optimizing for text humans rate as good.
RLHF (reinforcement learning from human feedback): The standard training method used to align most large language models, which optimizes for text a human rates as good, not for fast structured judgments.
System One model: The category Typesafe AI places Jev in: a model built for fast, intuitive-style decisions like classification or scoring, rather than slower, deliberate text generation.

Resources

Things they pointed at.

09:52linkTypesafe AI docs ↗

07:14tooltldraw (canvas-control demo)

08:17toolTweet Tester (viral tweet scorer)

11:01productEyedropper (Chris's own design-system tool)

14:20linkClaude Builders (Skool community) ↗

14:20linkAI Apps (Skool community) ↗

Quotables

Lines you could clip.

02:34

“That took 8.5 seconds.”

blunt, punchy contrast line right before the speed payoff→ TikTok hook↗ Tweet quote

03:13

“Jev can pick an action to do based on a specific option, it can classify something against a set of fixed criteria, it can score or rank something based on a defined set of levels or ranks, it can route something to a different option, and it does it at 100 times the speed of a traditional LLM.”

the single cleanest definition of what the model does, in one breath→ newsletter pull-quote↗ Tweet quote

08:46

“Categorisation based on a set of defined categories. Scoring based on a set of defined levels and criteria. True/false based on a set of defined parameters.”

on-screen recap slide framed as the whole thesis of the video→ IG reel cold open↗ Tweet quote

14:45

“Models like Jev are going to lead to a huge increase in the quality of software products being created.”

closing thesis, quotable as a prediction→ TikTok hook↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

So no doubt you've heard of this latest AI model from TypeSafe AI called Jev. And you've probably seen some videos and you know the hype is real. This thing is incredible.

If it doesn't work like a traditional LLM, it's a different way of thinking about AI. And I would go so far to say that Jev... is going to change software forever.

I want to break down why in this video but not only that I want to help you to understand a little bit better how it works, how to use it in your projects and also give you some use cases to show you kind of examples of what other people have done with it so you can start to think differently about how to get started. And so we're going to cover here what is Jev, how it works, some incredible use cases for Jev and then how to add Jev to your projects as well and I'm going to give you a prompt that you can just drop into your project.

to basically figure out exactly what you can use Jev for specifically. And so if you don't know, Jev is basically a new model from a lab called TypeSafe AI, but it's a model that works in a completely different way. So I want to break down some things that it can do because some of the announcements around Jev have been a little bit confusing, a little bit difficult to understand.

And I think the best way of figuring out what you can actually do with Jev is to understand what it's good for and see some real use cases of people who have actually built projects with it. it and then I'm going to drop the prompt into one of my projects and show you how you can start to figure out how you can use Jev inside of your own projects as well.

So if you've read any of the news around Jev you've probably seen the claims of it being like 200 times faster than Claude and working in a completely different way and maybe this idea of this kind of reinforcement learning method called RLCD instead of RLHF which is reinforcement learning from human feedback and RLCD basically just stands for reinforcement learning from calibrated decisions and this gives you a little bit of an indication of what Jev is actually good at and what it can do and then throughout the page here there's a bunch more information about how it's cheaper how it works but it's all quite technical and it's hard to understand so I want to show you some real use cases here so you get a sense of how you can start using Jev in your own projects this is a great explainer video that I found on X from Matija here.

Apologies if I said your name wrong. Basically where how an LLM answers is that it outputs a string of text in order to find the best possible match for the question that you've asked. So if you drop in an invoice and then you ask, is this invoice fraud?

The LLM will output text to answer that question in human language that we can understand. So based on the line items and the vendor history, this invoice appears to be legitimate. That took 8 .5 seconds.

Whereas for Jev, what it does instead is it takes the question, is this invoice fraud? It can give it a score across these different categories like fraud, clean or review. And in this instance, it's come up with clean as the result here.

And it will pass that result back to you as an answer or back to the app that it's built in as an answer as well. The other thing that it can do here that it's really good at is basically. this true or false determination so if you select an option here it would then say that is true and it's great for systems with a defined fixed set of actions that mean a specific thing and so this is what Jev can and can't do Jev can pick an action to do based on a specific option, it can classify something against a set of fixed criteria, it can score or rank something based on a defined set of levels or ranks, it can route something to a different option, and it does it at 100 times the speed of a traditional LLM or up to 200 times the speed if you believe.

the claim on the typesafe website. It really depends on the task that you're doing and the type of model that you're kind of comparing it to here. So let's have a look at some use cases here to understand this a little bit better.

So in this example you can see that Jev basically takes the text here and is determining what are the percentage of colors in this phrase and so it's doing that based on a set of categorizations around color for these individual terms here. So you can type in a term and you'll get the color mix below in this kind of chart here.

And this is happening super fast. And also the AI is figuring out these options. If you built software traditionally to do this, you would have to like build all of these values and all these categorizations behind the scenes.

Whereas with Jeff, you're just giving it the categories that it can choose from. And you're setting up a system for it to be able to provide answers based on whatever the user is putting into the system. an example of where I think something like Jev and this type of model has a huge impact on a wide variety of software beyond just you know being able to do these deterministic kind of ratings or categorization because this actually replaces a ton of different functionality in a lot of different types of app and it does it so much faster.

This is going to introduce a huge amount of opportunity for people building with Jev, for people building applications and products with Jev that just do things that you could never do before with software so much faster and more efficiently that LLMs just can't do that efficiently at all. So I want to show you some different examples here as well.

So Chris Tate has posted did an example where he's built a generative UI tool here which basically generates user interface based on the user's request and it's doing this with Jev versus doing this with a JSON style render. Now this shows you kind of an indication of the future of user interface generation for a lot of software where this is almost instantly generating custom ui on the right hand side without doing it step by step like you have on the left this is almost immediate and instant and it's doing this with jev this is just something that you would not be able to do with a traditional llm this is so much faster that it's happening here and again this has a huge amount of implications for software because it means that generative ui even though this is just an experiment generative ui is going to be something that we can legitimately use in a ton of different software applications moving forwards.

And so we start to be able to think about this idea of user interface as being something that's fixed to something that can be generated almost on the fly as quickly as defined user interface that is fixed. I don't think it's possible. It's very difficult to understand the long -term implications of this, but this is something that is huge for software in general.

Another great example here. from Nader from Cognition is he's been building basically a fuzzy search Mac desktop app where you can search for something that is very like fuzzy here, like a calculation or the PDF I just downloaded. And the results coming back from Jeff here are almost instant.

That is how fast it is because the things that Jeff is doing behind the scenes is basically determining the most likely result based on a set of criteria that is defined. in order to provide these answers so quickly. You can see here on the right hand side, it's got like a percentage.

It's like that's the percentage likelihood that that's the answer to the question. And that is what Jeff is great at doing. And this, again, is just going to be one of thousands of applications for Jev across a wide range of different software.

Another example that I really love here as well is basically controlling a canvas like this and then asking for a request that is more deterministic, like make a blue square, and then just have Jev do it instantly on the canvas. This is using TL Draw. Again, this is so much faster than it would be if you're using computer use or even an MCP with a traditional LLM hooked up to a software like this.

This is just so much faster. And again, this has massive implications. You can imagine being able to control a computer using your voice like this for deterministic actions that has a wide range of...

a wide range of implications across a ton of different software and i want to show you this example as well which is kind of like an example that a lot of people have been building here where you basically are determining like the viral score of a post for x and it's giving you again it's giving you that ranking based on a set of criteria for a string of words or a string of characters that you're typing and these are against a fixed set of criteria that you have defined up front.

And so there are some super interesting use cases for Jev and hopefully you get an understanding of the kind of thing that Jev can do and why it has such huge implications I think across such a wide variety of software and opens up opportunities for so many different types of products to be built. Now to kind of recap what Jev can do it's like I think it's great for these three things basically.

One is categorization and it's based on a set of defined categories so you have to define what the categories are and then Jeff will do the categorization super fast for whatever you're building. It's great for scoring again based on a set of defined levels and criteria and it's also great for these true or false judgments.

based on like how likely is it to be yes or no, based on a set of defined parameters as well. So these sorts of things is what Jeff is great at. It's not an LLM that writes text back for you, but it's great.

adding into applications and software and tools where these kind of needs are really really important and it opens up a huge set of new use cases in software and so how do you actually get started with jev well i wanted to create a prompt here basically for you to drop into a project just so that you can figure out how jev could actually be useful inside of something that you're working on so this is basically a way of instead of having to think about what jev is going to be useful for in any project that you're building just to give you a prompt that you can drop in to help you find a useful place to use jev in this project which is exactly what it says here help me find a useful place to use jev in this project read the documentation and inspect the project's code and documentation look for existing features where jev could make a small clearly defined decision choosing between categories scoring against something with defined criteria or assessing whether a statement statement is true suggest up to three use cases for each explain where it fits in the project what problem it would solve for the user what information we would send to jev the specific question jev would

answer and which question type fits how the project would use the answer and what should happen if the answer is uncertainly incorrect or unavailable how we could test whether it improves the current behavior prefer small changes to existing features keep ordinary rules for decisions that code already handles reliably don't add ai without a clear benefit and don't assume jeff's confidence means the answer is correct recommend the strongest starting point and explain why so this is going to be a really good prompt just to drop into an existing project if you want to understand where you can start using jev inside your own project today and so i'm going to take this prompt here and i'm actually going to drop it into one of my own projects and you can see the sort of thing that that this is going to come back with, the sort of ideas you can kind of find in your own projects.

So I'm going to jump over to Cloud Code. I'm going to go into my recent Eyedropper project, which if you don't know what Eyedropper is, Eyedropper is a cloud -based design system storage tool where you can basically store your design systems and access them with any agent. And it also verifies your code versus your design system.

So basically like a design review, like a code review, but for design systems, basically. And so I'm going to paste this prompt into this project. and see what it comes back with with some ideas of how we can implement Jev inside of this project.

So let's give this to Claude Code here. I'm just going to paste this prompt in and send this off. This is set to Fable 5 .1, and this is set to High as well.

Okay, so I've got some ideas here back about how I can use Jev in my own project. So the first one here is, I'm going to break these down a little bit as well, but the first one here is rule checks in Verify. So basically for this design system tool, it verifies any changes an agent makes.

versus your documented design system here. So currently what we're doing is only comparing colors, font families, and sizes. It never reads payload or rules.

Rules like never place two primary buttons in one view. So what we can do here is we can start to do these checks against more qualitative categorizations like don't place two primary buttons in one view. And so that is going to allow our agent to check versus the design system, whether it's following these qualitative design rules in from the design system or not and this basically is going to make our design output way way better and it's going to mean that this tool is even better because it's going to be able to check whether or not we're following the design system way way way more accurately compared to how this product was working before.

We can also potentially hear filter false positive color violations as well and so what this is going to do for us is basically the current checker is flagging every single color that it finds even those colors inside SVG paths and so what it's going to do is basically be able to determine whether it's a color that it should check or whether it's a color that it shouldn't check before actually doing a check versus the design system so this is going to fix a load of false positive color violations that come back so where eyedropper would be saying this doesn't match the brand this doesn't match the design system but we're in our actual project it would match the design system and it would be completely fine because we are allowed to have that exception when it comes to a color for example and then the last recommendation here is a scoring rule quality in the vision extraction loop and so what this is going to do here is that you give it your project or a website url or an image that you want to extract the design system for and this would allow us to basically

rate the quality of the agent extraction of that design system and then if it doesn't pass the level of quality that we expect from the design system extraction here it can then basically re -run this and do one more corrective turn asking the model to rephrase those rules because at the moment we're just checking with an llm based on these vague rules of keep it clean and modern for example but with jeff we can actually give it specific rules that we want the design systems to always be able to follow and then jeff will be able to check against to say yes or no it has or hasn't passed and is up to the level of quality that we expect from this design system extraction so that is how we could use jev in this project copy the prompt and run it in your own projects.

I've left it in the description down below so you can literally copy and paste and if you want a more detailed guide to get Jev up and running inside of your project I've added a playbook over in my free community which you can find in the link in the description down below or if you want more direct support on how to add Jev to your projects you can do that in my other community over on school as well and again the link is in the description down below.

I think ultimately Jev is going to be one of these tools which On the surface, it doesn't seem like it's going to have a huge impact. And when you look at a product or a piece of software, it's just going to work.

You're not even really going to feel it unless you really know what the differences are and how Jev actually works behind the scenes. But it is going to have massive implications across all of software. And the opportunity that this opens up for so many software products to be rebuilt and rewritten and recreated in a much better way means that models like Jev are going to lead to a huge increase in the quality of software products being created.

across the board, and a huge number of software companies being replaced by newer and better versions that are created by much, much smaller teams of people, maybe even individual builders as well. So hopefully that's helped you understand how you can get started with Jeff, why it has such huge implications for all of software in general.

I'm super excited to start building with this model and see what it can do, and I'd be super interested to see what you build with it as well. If you enjoyed the video, don't forget to like and subscribe. Thank you for watching, and I will see you next time.

The Hook

The bait, then the rug-pull.

A new model called Jev is making the rounds for being up to 200 times faster than a normal LLM, but the speed comes from a trade: it can't write you a paragraph, only a score, a category, or a true/false call.

Frameworks

Named ideas worth stealing.

01:36concept

RLCD vs RLHF

Jev is trained with reinforcement learning from calibrated decisions (RLCD) instead of the standard reinforcement learning from human feedback (RLHF), which optimizes it for consistent scores and classifications rather than human-preferred prose.

Steal fordeciding whether a feature needs a full text-generating LLM or just a fast, calibrated classifier

08:46list