Shadowing Practice: The BEST Jev Use Cases for AI Coding (Absolute Game Changers) - Learn English Speaking with Video

Kies een oefenmodus

Elke modus opent een volledig scherm oefenruimte.

226 zinnen

Als zinnen te kort of te lang zijn, klik op Bewerken om ze aan te passen.

Jev is incredible.

It was released recently and it popularized a type of AI model called System 1 Models, which specialize in making decisions instead of generating text.

And so it's actually way different from LLM's LightCloud and GPT.

And so it's opened up a whole new sprawl of use cases that everyone is sharing on the internet right now.

And people are sharing a lot of really fun and cool use cases with Jev, but something I'm hearing a lot, especially from people in my Dynamis community is that the use cases are cool,

but they're not always the most practical, right?

There's not a lot that you see and you're like, okay, I need to go incorporate this in my AI workflows right now.

And so that's why I want to make this video, just quickly showing specifically for AI coding,

for incredible JEV use cases to make your AI coding workflows faster and more token efficient, which is a big deal right now, especially with how bad the rate limits are.

Now, if you follow the latest in AI, there is a very good chance that you've heard of JEV and probably even tried it out for yourself.

Now, JEV is not the first kind of decision model like this, but that's a whole other topic for another video.

The point is JEV is really powerful.

The way it works is you give it some kind of situation, which they call state, and then you also supply with a list of multiple choice questions.

And in parallel, it's going to answer each one of those questions with a probability, which is basically its confidence score.

Now, the thing is you can already do this with large language models, especially with structured output, you can have it make decisions that you can key off of for the rest of your workflow.

But what makes JEV so awesome is

that it is 20 to 200 times faster than LLMs at making decisions and it's also 40 to 1000 times cheaper,

obviously the big range here being you can use different LLMs to compare against JEV, but no matter the LLM that you use, JEV is going to be more accurate,

faster, and cheaper for making any kinds of decisions.

And so at a high level, when you think of like Jev as the decision maker, that's an endless number of possibilities that you can use it for.

And so that's why I want to get really specific with you here, just quickly showing you, giving you inspiration for different ways that we can use it very practically.

Now for each one of these Jev use cases, they're valuable enough where I can make an entire video going into how to build and incorporate it.

But for right now, I just want to stay more high level.

I want to keep this short and sweet, giving you inspiration here so you can even pick a couple of these and maybe build them out yourself.

And then also in my Dynamis community this Friday, I am running a workshop getting a lot deeper into these use cases.

So check that out if you're interested.

And yeah, like I said, a lot more content coming soon, diving deeper into JEV because this is exciting for me.

I actually said this in my first video on JEV.

This is the first AI model in a while that I'm genuinely excited for.

And I think you'll see why as we get into these four use cases here.

So with that, let's just get right into it.

My favorite use case for Jev right now in my AI coding workflows is for security.

Because the thing is, and you've probably seen this yourself, AI coding assistants are way too willing to do things that they shouldn't, like read your environment variables, delete an entire folder.

Even if you have things in your global rules or skills to not do this, especially once you really start to bloat the context of a conversation,

or if you have a prompt that kind of gives it a workaround, it's gonna figure out ways to do these things.

And so that's why we need guardrails to prevent our agents from performing destructive actions.

And JEV can really be that guardrail.

So the most popular and effective way to implement these guardrails for our coding agents is using hooks, which was introduced in Claude Code,

but now pretty much every single coding agent has the idea of hooks,

where we can attach automations to run at different events that take place in the life cycle of our coding agent.

And so the most popular event is pre -tool use.

So when the agent is about to perform an action, like read a file or run a command, we can run an automation to basically analyze that

and either block the agent from performing that action or allow it to continue.

And so you can see where we're going with this here

because one of the most popular use cases is having a pre -tool use hook

that tries to analyze the agent's action to determine if it's going to read a .env file, right?

We don't want our secrets exposed into the context of our coding agent.

And so it has the opportunity to dish out an error code to essentially block that action, so the agent has to do something different,

like for example, reading the .env .example instead.

Now, the problem with this hook until Jev is that we either have to have an LLM analyze every single call,

or we have to have some kind of deterministic process with regular expressions.

Either way, it's going to be expensive or not very accurate.

Now, let's just scrap the idea of using an LLM right away, because if we're going to analyze every single action the agent wants to take, that's going to cost you hundreds

or thousands of dollars throughout the month just to block these sensitive calls that might happen once in a while.

And so what I've done until Jev is I use regular expressions.

And so I have a hook that runs

that just does pattern matching to try to figure out the agent is trying to do something like reading my Google credentials, reading my .env, deleting a folder, whatever it is

but the problem is There are so many different ways that an agent is able to do these destructive actions, because it can read the file directly,

it can write a Python script to do so, or a bash command, like, right, there are a million different things.

And so we have this massive laundry list here, and this doesn't even catch everything.

And there are also a lot of false positives.

And so what I've done is I've taken this pre -tool use hook, and I've replaced it with my JevGuard.

And I'll show you some stats in a little bit.

This is so cost effective and reliable.

So with System 1 models, again, we give it state and a list of multiple choice questions.

And so for anything that can go wrong with an agent action, I'm asking if it is the case, right?

Like, are we exposing secrets?

It's going to say either true or false.

And we give some instructions for added context.

This is part of the state.

And then is it destroying any data, like removing an entire folder, any kind of exfiltration, where we're maybe sending sensitive data out, like through a prompt injection attack.

And then another really cool one here is where you can just analyze is the agent going off task.

And so we can use this pre -tool use hook for even more than just security, just generally having another sort of model as a judge, making sure that we're staying on track for what we are trying to accomplish.

And then as far as the state goes, the situation that's the main input to Jev, we're giving it the tool name, the effect of it, the input, like the arguments to the tool, and also our current working directory.

And so that gives it the holistic picture.

And so when I ask Jev, I'm actually just using Jev right through open router with their new decision endpoint.

And then I'm giving it this state along with all the questions that I showed you above.

So I've only been using this hook for a little bit since Jev just came out, but my initial results are incredible.

So my previous version of the hook using regular expressions, you can see that it didn't block that many of the risky calls.

Now, obviously risky is subjective.

I've been pretty happy with this hook overall, but the main problem I've had with it is the false positives, blocking things that really shouldn't be blocked,

like just writing the word .env out to a markdown document.

And then going to using an LLM, it does a really good job.

I mean, not that many false positives, it blocks most risky calls, but even using something really fast and cheap like Haiku, it still takes over a second.

And yeah, it's only about a tenth of a penny per analysis, but that really adds up when your agent makes thousands of calls every single day.

And then we get to Jev.

Jev blocks almost every single risky call, barely has any false positives.

It is a quarter of a second for every single analysis, and it is a fraction of a fraction of a penny.

So it's cost effective, and it's fast.

It gives us essentially the reasoning capability of an LLM for this kind of decision, but it feels like it's free.

I mean, I know it's not quite free, but yeah, it's not like it breaks the bank in any way.

All right, so our next use case is game playtesting, and this really applies to any type of application

that requires a model to make snap decisions or respond to things in real time.

I'm just using video games as an example

because it's really cool to watch Jev play the game and it is something that I'm building myself for real.

And so with anything like a game, when you have 60 frames per second or 30 frames per second, a large language model is way too slow to respond to things.

By the time it analyzes the scene to make a decision, the scene is already passed, right?

And the character is gonna be dead in the game, for example.

But Jev is able to keep up.

100

It is incredible to watch.

101

And this is also very practical because we always want to have that validation step in our AI coding workflow.

102

So for a video game, you know, after we build the next feature, we want the model to be able to play the game as a user actually would.

103

And that wasn't really realistic before until Jev.

104

So take a look at this.

105

I have a live example of Jev playing one of the games that I'm building a proof of concept for right now.

106

It looks like I'm playing.

107

The character is attacking, dodging, moving around the map.

108

You can see the decisions that Jev is making on the left -hand side right here, with probabilities for all the different actions that we're giving as the options.

109

Because, again, it's all about the state, which is, you know, where everyone is in the game, and then the decisions, like, what move are we going to do next?

110

And I have hands off the keyboard.

111

It seriously looks like I am playing this right now.

112

It is so cool.

113

And so as it's making the decisions and processing the state of the game, we can also analyze how things are going in general

114

and act on that, right? like maybe we do discover bugs for real as we're playing the game, the kind of thing that an LLM could never really discover by itself just by, you know, running unit tests.

115

And so I've been running this for real as I've been building new features in the game, and it's genuinely caught bugs that the large language model was not able to by itself

116

because the LLM can't really play the game.

117

And yes, it can run like other tests and harnesses that I build, but that's more deterministic and it's not really playing the game as a user actually would.

118

And so the important thing is we still have to use a large language model to build the harness for JEV, right?

119

Like it has to figure out how do we translate the state of the game into the input to JEV?

120

What are the options that we give it for different moves it can perform?

121

So we build that up front with the LLM, but then all of our testing going forward uses JEV.

122

So it's super fast, reliable, and cost effective.

123

One other thing that I have experimented with in the past for video games is making it

124

so that the large language model can actually slow down the game.

125

So it can play it frame by frame.

126

That was kind of my way to have it actually play the game as a user would before JEV, but as you can imagine, that was incredibly slow and expensive.

127

Now, I hope you can also see the pattern emerging as we're going through these use cases.

128

We are never really going to use JEV by itself.

129

It is super powerful to use it in combination with LLMs, because Jev is really good at making decisions,

130

but it can't craft the decisions in the state upfront or really act on them.

131

And so the best way to use Jev is generally to sandwich it in between calls to a large language model.

132

Like for example, with gameplay testing, we have an LLM build the harness and then act on the bugs that Jev finds when it plays the game.

133

Or with the security here, we have the coding agent performing different actions, Jev analyzes an action, and if it blocks it, then the agent, the LLM,

134

has to figure out something else to do, right?

135

Jev is never really the end of our workflow.

136

It's always just making parts of our workflows faster and more efficient.

137

Now, another really good example of this takes us to our third use case with browser testing, using a model to go through a webpage

138

and operate it as a user would in the validation step of our AI coding workflow.

139

It's very similar to gameplay testing.

140

But the thing is, large language models have typically been decent at this, because unlike with something like a video game,

141

an agent doesn't have to respond in real time to events with a website, usually, and so it's able to take its time and analyze the page to pick the next action.

142

But, you guessed it, it is still slow and expensive using an LLM compared to JEV, and JEV is even more reliable for this kind of browser automation.

143

So you probably use tools like the Playwright MCP or Vercel's Agent Browser CLI to do browser testing with an LLM.

144

And now we have a lot of open source tools coming out, the same kind of thing, but using Jev instead of an LLM.

145

And it works incredibly well.

146

There's a lot of cool examples here showing at different websites that Jev is clicking around.

147

The most important thing to keep in mind is you don't

148

always have the opportunity to use Jev for literally everything because Jev can't generate text like an LLM can.

149

So if there's anything that requires freeform text as an input to a site, typically you still need a large language model for part of the workflow.

150

But as much as you possibly can, you want to use Jev when you're just making decisions like what should I focus on or what button should I click.

151

And so most of the workflow for your browser automation should be driven by Jev now.

152

So I'll link to this GitHub repo in the description.

153

This is the best open source project I've seen for Jev browser use.

154

But yeah, there are a lot of them.

155

And you can also roll your own.

156

I built my own browser automation with Jev as I've been testing it out.

157

Like on this app right here, this is DynaChat, which is in production right now.

158

You can go to chat .dynamist .ai and talk to this agent.

159

It basically is able to search through all my YouTube content.

160

And then if you're logged in with the same email you use in the Dynamist community, it'll also pull from my workshop and course content.

161

So it's a really cool app.

162

And I've tested building different features and having Jev go through them exactly as a user would.

163

So I won't bore you with a full test run right now, but I do want to show you just really quickly live Jev working on this site.

164

And so any text that you see at input is pre -generated from an LLM, but everything else it is deciding live.

165

The chat box to click into, the button to press to sign in, for example, and then also everything

166

that it's doing here can be analyzed by the LLM after to figure out

167

if there's any bugs that it needs to iterate on.

168

All right, the last of the four use cases here for Jev is workflow classification.

169

And this is becoming more and more important for me over time time.

170

I want my workflows to be dynamic.

171

For example, I don't always want to use the same large language model.

172

It depends on the difficulty of the task.

173

And so for the sake of token efficiency, I might want something at the start of the workflow that classifies what tier of model I need to use.

174

Another good example is sometimes based on the type of work that comes in, I need to be using different skills or different steps.

175

And so a really clear example of this is when you have a GitHub issue that you want to work on.

176

It might be a bug that you have to investigate and fix or a feature that you have to plan and build.

177

And so I don't wanna have to make that decision for myself.

178

That's not gonna scale with my AI coding workflows.

179

I need something to classify that and direct the workflow at the beginning.

180

And that is what Jev is for.

181

And this exact workflow I'm describing to you here with the different classification steps, I built that as an Archon workflow.

182

So I've covered Archon a lot on my channel before.

183

It's my open source harness builder

184

that allows you to build these larger AI coding workflows very easily for a lot of the different things

185

that I've been covering in this video.

186

And of course, I've been incorporating Jev with my Archon workflows.

187

And so what you're looking at right here is the graph visualization, where we take in a GitHub issue, and we use Jev to classify two things.

188

What is the tier of model that we need to knock this out?

189

Because maybe it's something super simple, and we can't just use something like Sonnet 5 and then also deciding the route.

190

Is this, again, like I said earlier, a bug we have to investigate and fix or is it a feature we have to plan and build out?

191

And so this is the YAML file that makes up the entire Archon workflow.

192

And for each step where I wanna call upon Jev, I just have this Python script where I give the arguments and it forms the decision,

193

asks Jev, and then the rest of the workflow is going to act on the output of Jev.

194

And I'll even quickly show you the Python script

195

because we can see all the questions we're sending into Jev at the very top.

196

It is so powerful how you can ask a ton of questions that Jev will answer in parallel for super cheap.

197

So like, what kind of work does this GitHub issue ask for?

198

Is it, you know, a bug or a feature that determines the skills that we use for the rest of the workflow?

199

What's the tier of model that we need, right?

200

Like based on the difficulty of the task, a fast model, like, I don't know, GPT -6 Terra, something standard like Sonnet 5 or GPT -6 Sol,

201

maybe a strong model like Opus 5 .5 or GPT -6 Astra.

202

You get the idea, right?

203

Like Jev is making that determination.

204

And in my testing, it does a very good job just generally understanding the difficulties of tasks and the type of tasks.

205

And so back over to this specific run for the classification here, it figured that it is a bug that needs to be investigated.

206

And then for the tier selection here, I'll go to the logs really quickly.

207

I know it's kind of hard to pick out, but when the next step ran, it did investigate standard, as in it was using that middle tier of the model here.

208

So whatever I have selected for that, something like Sonnet 5.

209

And of course, I was the judge myself for all the JEV testing that I did here.

210

So I ran this Archon workflow 12 times and every single time I completely agreed with the decisions, with the classifications that it made up front.

211

There's also a separate Archon workflow more for pull requests reviewing.

212

And so using classification up front to figure out what kind of review do we need?

213

Like, is this a bigger thing that needs a full architecture review

214

or just a light chore that has to be validated quickly?

215

and it wasn't perfect but still 15 out of 16 is pretty darn good and

216

if we look at the cost here a fraction of a penny versus what it would typically cost in llm

217

and again 32 cents per pull request

218

that is really going to add up especially with a project

219

like archon where we are dealing with dozens hundreds of pull requests

220

and issues every week

221

so there you have it those are my four favorite use cases for using jev in ai coding workflows

222

and of course let me know in the comments

223

if you want me to make a dedicated video for any of these

224

because I could certainly go a lot deeper and help you incorporate these into your workflows as well.

225

And so if you appreciated this video, you're looking forward to more things on JEV and AI coding, I would really appreciate a like and a subscribe.

226

And with that, I will see you in the next video.

App downloaden

Alles wat je nodig hebt om vloeiend te spreken

AI UitspraakScoor elke zin

IPA OefeningBeheers elk geluid

WoordenschatBouw je woordenschat op

WoordenspelLeren terwijl je speelt

Scan QR

Download on theApp Store Get it onGoogle Play

✨ Aanbevolen Video

169 zinnen

What Is Jev? The AI Model That Doesn't Generate Text

Daily ConversationUniversity StudentsWorking Adults

108 zinnen

How I Learned Procedural Generation

Daily ConversationUniversity StudentsWorking Adults

215 zinnen

Creator of C# and TypeScript: "AI will NEVER Replace Coders, Here's Why" | Anders Hejlsberg

Daily ConversationUniversity StudentsWorking Adults

75 zinnen

Woordenschat en spreektips bij deze les

Deze spreekles op niveau C1 is gebaseerd op de video “The BEST Jev Use Cases for AI Coding”. Deze woorden komen het vaakst terug: jev, workflow, model, llm, agent. Deze video bevat 226 zinnen en 3837 woorden om na te spreken. Het gesproken deel duurt 17:38. De spreker praat snel, ongeveer 218 woorden per minuut, dus reken op verbonden en ingeslikte klanken. 84% van de woorden hoort bij de 3.000 meest gebruikte Engelse woorden; de rest kun je beter vooraf bekijken.

Belangrijke woorden in deze video

De 15 moeilijkste woorden uit de video, met uitspraak en betekenis:

Woord	Uitspraak	Betekenis
analyze werkwoord	/ˈæn.əˌlaɪz/	analyseren
automation zelfstandig naamwoord	/ˌɔ.təˈmeɪ.ʃən/	automatisering
harness werkwoord	/ˈhɑɹ.nəs/	inspannen, optuigen
incorporate werkwoord	/ɪŋˈkɔɹ.pɚ.eɪt/	inbouwen, inlijven
risky bijvoeglijk naamwoord	/ˈɹɪski/	gewaagd, riskant
classify werkwoord	/ˈklæs.əˌfaɪ/	rangschikken, classificeren
guardrail zelfstandig naamwoord	/ˈɡɑɹdˌɹeɪl/	vangrail
folder zelfstandig naamwoord	/ˈfoʊldɚ/	hechtmap, map
fraction zelfstandig naamwoord	/ˈfɹæk.ʃən/	fractie
penny zelfstandig naamwoord	/ˈpɛni/	penny
validation zelfstandig naamwoord	/ˌvæl.əˈdeɪ.ʃən/	validering
token zelfstandig naamwoord	/ˈtoʊkən/	teken
prompt werkwoord	/pɹɑmpt/	aansporen, aanmoedigen
destructive bijvoeglijk naamwoord	/dɪˈstɹʌktɪv/	destructief, destructieve
gameplay zelfstandig naamwoord	/ˈɡeɪmˌpleɪ/	spelervaring, gameplay

Phrasal verbs die je zult horen

Woord	Uitspraak	Betekenis
figure out werkwoord		uitvogelen, er achter komen
come out werkwoord	/ˌkʌm ˈaʊt/	uitkomen
go off werkwoord		afgaan
hands off		afblijven!, niet aanraken!
keep up werkwoord		bijblijven
look forward to werkwoord		uitkijken naar, zich verheugen op
slow down werkwoord		afremmen
take over werkwoord		overnemen

Grammatica in deze video

De structuren die de spreker het meest gebruikt, met de exacte woorden uit de video:

Structuur	In de video
Present perfect continuous have/has been + -ing — iets dat eerder begon en nog bezig is	I've only been using · I've been running · I've been testing
Present perfect have/has + voltooid deelwoord — iets uit het verleden dat nu nog telt	you've heard · you've probably seen · I've done
Lijdende vorm be + voltooid deelwoord — het gaat om wat er gebeurt, niet om wie het doet	was released · was introduced · be blocked
Betrekkelijke bijzinnen who / which + zin — extra informatie over een persoon of ding	efficient, which is · probability, which is · hooks, which was

Uitspraak om op te letten

De spreker gebruikt 72 samentrekkingen en verkorte vormen, zoals I've, I'm, we're. Spreek ze kort uit, zoals je ze hoort.

De klanken “sh” en “zh”: automation /ˌɔ.təˈmeɪ.ʃən/, fraction /ˈfɹæk.ʃən/, validation /ˌvæl.əˈdeɪ.ʃən/, credential /kɹɪˈdɛnʃəl/, specialize /ˈspɛʃəˌlaɪz/
Lange woorden — let op de klemtoon: automation /ˌɔ.təˈmeɪ.ʃən/, incorporate /ɪŋˈkɔɹ.pɚ.eɪt/, deterministic /dɪˌtɜː.mɪˈnɪs.tɪk/, validation /ˌvæl.əˈdeɪ.ʃən/, probability /ˌpɹɑ.bəˈbɪl.ə.ti/

Klanken die Nederlandstaligen lastig vinden:

Stemhebbende eindmedeklinker — /b/, /d/, /g/, /z/, /v/ niet verscherpen: analyze /ˈæn.əˌlaɪz/, destructive /dɪˈstɹʌktɪv/, specialize /ˈspɛʃəˌlaɪz/, workaround /ˈwɜːk.əɹaʊnd/, subjective /səbˈd͡ʒɛktɪv/
/æ/ — opener dan de Nederlandse “e”: analyze /ˈæn.əˌlaɪz/, classify /ˈklæs.əˌfaɪ/, fraction /ˈfɹæk.ʃən/, validation /ˌvæl.əˈdeɪ.ʃən/, validate /ˈvæl.ɪ.deɪt/
/g/ — een harde plofklank, geen Nederlandse “g”: guardrail /ˈɡɑɹdˌɹeɪl/, gameplay /ˈɡeɪmˌpleɪ/, graph /ɡɹæf/

Zo oefen je met deze video

Luister de hele video één keer zonder te spreken en noteer de woorden die je niet kent.
Begin op 0,75× snelheid, spreek zin voor zin na en ga terug naar normale snelheid zodra het makkelijk gaat.
Neem jezelf op en vergelijk met het origineel; let daarbij op woorden als analyze, automation, harness.

Wat is de Shadowing-techniek?

Shadowing is een wetenschappelijk onderbouwde taalleermethode die oorspronkelijk is ontwikkeld voor professionele tolkentraining en gepopulariseerd door polyglot Dr. Alexander Arguelles. De methode is eenvoudig maar krachtig: je luistert naar native Engelse audio en herhaalt het onmiddellijk hardop — als een schaduw die de spreker volgt met slechts 1–2 seconden vertraging. In tegenstelling tot passief luisteren of grammaticadrills, dwingt shadowing je hersenen en mondspieren om echte spraakpatronen tegelijkertijd te verwerken en te reproduceren. Onderzoek toont aan dat het de uitspraaknauwkeurigheid, intonatie, ritme, verbonden spraak, luisterbegrip en spreekvaardigheid aanzienlijk verbetert — waardoor het een van de meest effectieve methoden is voor IELTS Speaking-voorbereiding en echte Engelse communicatie.

Shadowing-techniek: lees de volledige stap-voor-stap-gids →

Shadowing Practice: The BEST Jev Use Cases for AI Coding (Absolute Game Changers) - Learn English Speaking with Video

Kies een oefenmodus

App downloaden

What Is Jev? The AI Model That Doesn't Generate Text

How I Learned Procedural Generation

Creator of C# and TypeScript: "AI will NEVER Replace Coders, Here's Why" | Anders Hejlsberg

What AI can (and can't) currently do in a real lab | Jennifer Doudna

JUST $1 For Billions of Tokens?! (DeepSeek v4 Pro)

Agentic AI Frameworks Explained: Workflows, Multi-Agent, & Production

Enhancing AV Simulation with Generative AI - DRIVE Labs Ep. 36

A $6.3 billion open-weight model just got embarrassed by the French...

Learn 10X Faster In 10 Minutes

We Let $200 GPT-Pro Think for 7 Days on Unsolved Math

Is ML Engineering Dead? (AI vs ML Engineer)

Harnessing generative AI in architecture, engineering & construction

Woordenschat en spreektips bij deze les

Belangrijke woorden in deze video

Phrasal verbs die je zult horen

Grammatica in deze video

Uitspraak om op te letten

Zo oefen je met deze video

Wat is de Shadowing-techniek?