Insane Jev Uses You Need To Use Right Now transcript

Jev is the fastest model out there and people have been using it in a lot of insane ways ever since it was released. But the biggest difference we found was when we connected Jev with the coding agents that we use every day. So we tested Jev in our own workflow and found seven places where Jev makes a huge impact. And not only does Jev make your agent way faster and cheaper to run in these places, but it also fixes some problems that your agent always had.

If this is your first time, we're a software company and this is our channel, AI Labs. And in this video, we're going to show you all seven Jev use cases, what each one changes in your workflow, and how to use them. This section is for those who don't know what Jev is. And if you already know it, you can skip ahead to the next section using the timestamps in the description below. Now, Jev is an AI model made by a company called Typesafe.

Unlike other models like Claude and GPT which write their answers out in text, Jev doesn't do that and instead it picks from a given set of options which is why it's also called a decision model. So instead of the way you prompt Claude and other models, Jev chooses from options whose answer can be either a yes or no or a list to pick from or a score to give to anything and it will respond by choosing between them. And along with its pick, it also gives you a number called confidence value.

Confidence value is a number that shows how sure the model was when it chose between the options. And Jev is also way faster than other models. This is because models like Claude and GPT write their answer one token at a time. But Jev doesn't work like that. Jev answers all of your questions at the same time and gives you a number at much higher speed. Now you might think that models like Claude can also make these decisions themselves.

But the problem with these models is that they have to think and write every answer. So each one costs you time and usage. But Jev doesn't write huge amounts of text like those models because it just gives one decision. So each decision takes a fraction of a second. Jev is also a lot cheaper than the usual models because it isn't writing tokens like the others are doing. You only pay for what you send to Jev and the answer it sends back is completely free.

Now Jev isn't a model that works inside Claude code or codeex as a replacement for all of the models that you have on it. Jev is just used for decision-making only because it doesn't write text like the other models. It can't be used to write code or let the model use tools. It can be used just as a decision maker inside tools like claude code and codeex. You can get access to jev via types safe's own platform. But the problem is that new signups are paused as of now because of the increasing demand.

But it is also available on other platforms like open router and versal AI gateway. Both of them are platforms that give you one key to use AI models from lots of different companies and Jev is one of those models. You can use whichever you want, but we went with Versal AI gateway. To create the API key, you need to open your Versal dashboard and go to the API keys page inside AI gateway. When you create a key there, versal only shows it to you once, so you need to copy it right away because this is the exact key that you will be using in your workflow.

Then you need to use the export command in the terminal to save the key as an environment variable. An environment variable is basically a saved value that anything you run in that terminal can read. So when you open Claude in that same terminal, Claude can find the key and use it. The first use case of Jev is replacing the compaction method that coding agents like Claude code use. The usual compaction basically sends the whole conversation back to the model and asks it to summarize it by following a set of instructions and that can take a long time.

Jev is a good choice here because it can make a decision on whether something is important or not. It can actually read your conversation so far and decide what is important in the conversation and the model's responses. So instead of the compaction summary these models by default go for Jev gives the things that are actually important. To do this there is already a plug-in called fast Jev compaction and what it does is replace the compaction summary with Jev decisions.

You can install it by using their install workflow but that repo doesn't support the versal AI gateway that we were using because it was built for Typesafe's own platform. So what we did was copy the plug-in into the project that we were working in. Then asked Claude Code to make some small changes in it so that we could use it with the gateway as well. This plug-in uses a hook to redirect Claude from following its usual compact command instructions.

Since it's stored in the project folder rather than installed through the Claude marketplace, you'll need to ask Claude to update its settings. So it recognizes this plugin as well. Once you install it, you just run the compact command like normal. The plug-in hook takes over and replaces the usual compaction. It compacts much faster, usually in less than a second. There is also a limit for when it uses Jev for compaction.

If your session is below 25%, it will not use Jev. Instead, it will use the normal compaction with clawed models. This helps make sure the Jev API is only used when it can make a big difference. But before we move on to the next use case, it would be great if you subscribe to the channel and hit the hype button. This small gesture of support goes a long way for us. The second use case basically makes use of Jev's speed and low cost.

And it is about using Jev as a checking layer in between that makes sure whatever you want is done right. When you're working on a project, there are a lot of docs and files that describe what features you want and what features need to be built. The thing is that there are a lot of document files which can actually get hard for the agent to keep track of. Since your default model is the one that worked on the feature, we can't let it be the judge.

In order to make use of Jev's speed, we created a hook that runs whenever Claude edits the files that control who can access what in our app, and it asks Jev whether each rule in our docs has a test for it. This helps because it lets us find which rules were listed in the docs but never got a test. To use it, you just need to prompt Claude to check any particular part of your app and it will load the Jev skill, show you which rules are missing a test and then you can ask Claude to write tests based on the report Jev gave.

The third use case is about skills. Jev is actually a great model when it comes to making decisions. Agents only load the skills name and description in the context window. But there is a problem. When you're using a lot of skills on a project, the model has to consider all of them in the context window. And then from those skills, the model has to decide which ones to use and which ones not to use. That choice is actually something that you can make better by using Jev because Jev can make this decision much more quickly.

So for that reason, we created a hook called the skill picker. This skill picker basically works by reading the names and descriptions of every skill just like Claude Code does and then it reads your prompt and picks the one skill that fits it or none if the prompt doesn't need a skill. So when you're actually submitting anything, it will read the prompt first and then tell Claude which skill to use for that task. So Claude doesn't have to work that out from every skill on its own.

So when you're working on any task, you'll see that after every prompt, you give a hook kicks in and all your skills get selected way faster than it would have been normally without Jev. But before we move on, let's have a word by our sponsor, Zapier. If you've built an app, you know how quickly users start asking you to connect it to the other tools they use. What surprised us was how little it took. The whole integration is really just writing Node.js, and that one build reaches Zapier's 1 million users.

We scaffolded a new integration from a template, then wired up our own app, quicklink, a little URL shortener we built. We defined its short link object once, and that single definition became a new link trigger and a shorten URL action with no extra wiring. We tested it locally and pushed it up, and it showed up right in the Zap editor, ready to use in a real Zap. And once it's in there, your app sits alongside Zapier's 9,000 plus app ecosystem, ready to connect to the tools people already use. and Zapier handles the plumbing for us from storing our API key to polling for new links and quietly skipping the duplicates.

So, we only write the logic that's actually ours. Start free with the 14-day trial and the docs are linked in the description below. The fourth use case is about finding files faster. Now, you might already know that whenever the model has to find a file in your project, it always searches the files by actually running an agent called explore. It runs in a separate context window and just returns the exact file. So it doesn't fill up the main agents context window with information from the files it opened that weren't needed.

Up until a while ago, the default model Claude used for running Explore was Haiku, but then they changed it so explore now uses the same model as your main session. That means if you're working with Opus, Explore runs on Opus 2, which makes every search slower and more expensive. So to make use of Jev, you can create a skill that asks Claude to do what Explore does using Jev. You can also ask it to create an agent that replaces explore for this project only.

But we chose a skill because a skill can also store the scripts and other things it needs. The skill works in two steps. First, it runs a normal keyword search to find the files that might be related to your question. Then Jev scores those files 20 at a time on how closely each one matches your question. And Claude only opens the few files at the top. So whenever you give it a prompt, it basically loads the skill and runs that search and ranking.

And within a few seconds, Claude knows which files to read without opening all of them. Like it took 1.6 seconds to rank the 35 files and it put the right file first. The fifth use case is about reviewing code. Now you might already know that the agent that built a feature shouldn't be the one that checks it. That's why when we are working on our own projects, we always ask a different model to review the work. But there is a problem.

This review that runs whole is actually slow because of the way Claude normally does step by step. So, for that reason, we added Jev before the review starts. Jev doesn't replace Claude as a reviewer. It's just an extra checking step that helps Claude review things better. Jev basically reads the change and answers seven yes or no questions about it, like whether this change is actually allowed under the rules and whether it's something that should be changed in the first place.

If the answer to all of them is no, the reviewer only does one quick round. But if any answer is yes, or Jev isn't sure, the change gets the full review just like before. This helps because the risky changes still get checked properly and the small ones finish much faster. The sixth use case is about testing your app in the browser. When you're working on any app, there are times when the agent opens the browser and runs the app like a real human would and sees if what it built works well or not.

This helps find the kinds of issues that only appear when someone is actually using the app. Claude code can do this when you give it a browser tool and it has its model check whether the thing that was asked to be built was built properly or not. The model opens the browser and interacts with the app by clicking different buttons and it decides by itself where to click next. We can give that decision-making to Jev as well.

That makes testing faster because the final call on whether the app works still comes from the main model, but Jev decides where to click next much faster. So to help with that, we asked Claude to create a skill for it. The skill opens the app and makes a list of every button and link on the page. And then Jev picks the one that gets it closer to the goal. It clicks that, makes a new list from the next page, and repeats this until Jev decides the goal is done or that the page is blocking it.

In our app, we used it to sign in as an admin, a manager, and an employee and check that each of them can only reach the pages they're allowed to. And then Claude compares what happened against the rules in our docs. So, whenever you ask Claude to check the app in the browser, it loads this skill and uses Jev to test it, and it saves a lot of time compared to doing it normally. The seventh and last use case is about keeping claude to your rules.

When you've been working with agents, you would have noticed that there are times when they stop following what you already planned in the specs. The rules in your claw.md are just instructions. So the model follows them most of the time but not every time. For that, we created a hook because a hook runs every single time and the model can't skip it. So in our project, we have a lot of rules in other files that are specific to different parts of the app.

Then whenever Claude is about to edit a file, the hook sends Jev the change along with the rules for that file. And Jev answers with a yes or no whether the change breaks each rule. If Jev is at least 80% sure a rule is broken, the edit gets blocked and Claude is told exactly which rule it broke so it can fix it. When we tested it, we asked Claude to create a file that reads the employee data straight from the browser, which breaks one of our rules.

Jev decided that the change broke that rule, so the edit was blocked before the file was even created. and Claude told us exactly which rule it had broken. Now, all the skills and setup you saw in this video is available for you to use in our community, AIAS Pro. So, if you found value in what we do and want to support the channel, this is the best way to do it. The links in the description. That brings us to the end of this video.

If you'd like to support the channel and help us keep making videos like this, you can do so by using the super thanks button below. As always, thank you for watching and I'll see you in the next one.