21:38Jay E | RoboNuggets · Tutorial
The ARMS Framework: A 4-Part Agentic OS for Claude Code
A creator walks through his own Claude Code command center and the four-layer system underneath it: Skills, Memory, Routines, and Applications.
August 21stThe argument in one line.
Jev is a decision-only model, it can't write a sentence but can pick true/false, a score, or one option from a list almost instantly and near-free, so routing simple decisions to it before calling Claude cuts both cost and latency across nineteen builds.
Read if. Skip if.
READ IF YOU ARE…
- You build with Claude Code or another agentic platform and want to cut API costs by routing simple decisions to a cheaper model.
- You run a business with repetitive classification work, support tickets, comments, invoices, ad research, that currently burns big-model tokens on simple yes/no or category calls.
- You want copy-paste starter prompts for nineteen specific automations rather than a general explainer of what decision models are.
SKIP IF…
- You're looking for a tutorial on using Claude itself; this video is specifically about offloading classification work to a separate, cheaper model.
- You have no existing workflows or data to categorize; most of these use cases assume you already have a sheet, inbox, or comment feed to point Jev at.
The full version, fast.
Jev is a decision-only AI model, it can't generate text but can pick true/false, a category, or a confidence score in a fraction of a second for a fraction of a cent, up to 200 times faster and 400 times cheaper than a full language model. The video walks through nineteen ways to pair it with Claude Code: categorizing spreadsheet data, triaging customer emails and comments, tagging competitor ads, finding the best clips in long videos, scoring churn risk, and routing requests to the right Claude skill or model, each with a cost or speed benchmark and a starter prompt. The throughline is to let Jev handle the sorting so a bigger model only gets called when a task actually needs reasoning.
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 →Where the time goes.
00:00 – 00:54
01 · Intro
Jay introduces Jev as a fast, cheap decision-only model and previews 19 use cases to pair it with Claude Code, from easy to advanced.
00:54 – 01:30
02 · 1. Jev in Google Sheets
Claude builds a plugin where typing a new column name has Jev fill in every row from a fixed category list, fast and without inventing new categories.
01:30 – 02:34
03 · 2. Triage customer inquiries
Jev tags each inbound message (billing, bug, question) with a confidence score, routing only uncertain cases to a human; 217 transcripts sorted in 13 seconds for 7 cents.
02:34 – 03:07
04 · 3. Analyze competitors' ads
A Chrome extension pulls every ad from the Meta ad library and has Jev tag format, call-to-action, and funnel stage; 54 ads tagged in 1.5 seconds for under a cent.
03:07 – 03:34
05 · 4. Find the best clips in long videos
A clip finder scores every moment of a long recording for shorts-worthiness; 411 clips from a 70-minute interview scored in 6.5 seconds.
03:34 – 03:58
06 · 5. Score and profile your customer base
Jev reads SaaS account data and groups customers into healthy / needs-attention / at-risk buckets so churn can be caught before cancellation.
03:58 – 04:34
07 · 6. Build backlinks in a site or second brain
Jev links related blog posts or notes to each other automatically; 60 test posts linked in two and a half seconds.
04:34 – 05:04
08 · 7. Find buyers in your comments
Comments scraped from social posts get tagged by intent (ready to buy, question, complaint) so sellers get a priority list instead of scrolling manually.
05:04 – 05:38
09 · 8. Verify Jev's results
Before trusting any categorization, run Jev on a validation set of examples with known answers and check how often it matches, then recalibrate on the misses.
05:38 – 06:22
10 · Sponsor break: RoboNuggets community
Mid-video pitch for the RoboNuggets paid community (Claude Living Masterclass + Agents as a Service course) before moving into intermediate use cases.
06:22 – 06:59
11 · 9. Let Jev pick the right skill
Jev picks which of dozens of Claude Code skills matches an incoming prompt; found the right skill out of 145 in about 5 seconds total versus ~30 seconds for Opus.
06:59 – 07:34
12 · 10. Let Jev pick the right model
A slash command has Jev read each message and route it to the cheapest capable model, Haiku for simple jobs, a bigger model only when the job is hard.
07:34 – 08:03
13 · 11. Put Jev in front of your AI agents
Jev pre-filters an inbox before a bigger model reads anything; 1,700 emails sorted for 18 cents, tagging replies-needed, brand deals, and spam.
08:03 – 08:39
14 · 12. Build Chrome extensions
A browser extension asks Jev one yes/no question per post to fold away AI slop from a feed, or hide ads and cookie banners on any page.
08:39 – 09:09
15 · 13. Search by meaning
Instead of exact-match Ctrl+F, Jev splits a page into paragraphs and picks the best semantic match, fast enough to feel real-time.
09:09 – 09:56
16 · 14. Search your images by what's in them
Searching assets by content instead of filename needs written metadata first; a cheap model like Gemini Flash-Lite can caption 1,000 images for about 50 cents.
09:56 – 10:31
17 · 15. A live checker for what people say
Because Jev answers instantly, it can score spoken content live, sorting meeting sentences into decisions, action items, risks, and questions as they're said.
10:31 – 11:09
18 · 16. A chatbot with zero LLM calls
A narrow chatbot answers from a pre-transcribed video library using only Jev to pick the right match, no language model call required.
11:09 – 11:55
19 · 17. Smarter designs for apps
Jev picks the right icon or visual asset from a library as a user types, replacing either a costly language model or a brittle regex match.
11:55 – 12:24
20 · 18. Web pages that build themselves
Jev can't write code but can pick from a library of ready-made components (forms, buttons, fonts) and assemble a page per visitor at normal load speed.
12:24 – 13:07
21 · 19. Finding your own Jev use cases
Point Claude at shipwithjev.com plus a file about your own business, or have it review your past sessions, to surface where a Jev call would have saved time.
13:07 – 14:05
22 · Wrap up
Jay notes OpenAI's new Decisions API as proof other labs are copying this pattern, then points again to the free prompt PDF and closes out.
Lines worth screenshotting.
- Jev can be up to 200 times faster and 400 times cheaper than a general-purpose language model because it only picks an answer, it never writes one.
- In one test, Jev sorted 217 customer call transcripts into categories in 13 seconds for 7 cents.
- Jev tagged 54 competitor ads from three different brands in about a second and a half for less than a cent.
- A clip-finder tool scored 411 possible clips from a 70-minute interview in 6.5 seconds.
- Linking 60 test blog posts into an internal backlink structure took Jev only two and a half seconds.
- Jev sorted 1,700 emails for 18 cents, tagging which ones need a human reply and which are spam.
- Across 14 tests, Jev picked the right Claude Code skill out of 145 options in about 5 seconds total, versus roughly 30 seconds for Opus.
- TypeSafe, the company behind Jev, found that letting it route requests among 182 available skills cut wrong picks by more than half.
- Captioning 1,000 images for a search-by-content index costs about 50 cents using a small model like Gemini Flash-Lite.
- The way to verify Jev's accuracy is a validation set: run it on a few dozen to a hundred examples with known answers and check how often it matches.
- Setting a confidence-score threshold, for example routing anything Jev is less than 60% sure about to a human, lets you tune automation risk without retraining anything.
Route the easy decisions before calling Claude
DECISION ROUTING
A cheap, near-instant decision-only model can handle sorting, scoring, and routing so a bigger model like Claude only gets called when a task actually needs reasoning.
021. Jev in Google Sheets
- A decision model can fill in an entire spreadsheet column by picking from a fixed list of categories in seconds, instead of you tagging each row by hand.
- Because a decision model can only choose from your predefined list, it can't invent a category that doesn't exist, which makes it safer than a free-text model for strict categorization work.
032. Triage customer inquiries
- Tagging every inbound question with a category and a confidence score lets you route only the uncertain ones to a human, instead of a person reading every single message.
- A real test sorted 217 customer transcripts into categories in 13 seconds for 7 cents, showing how cheap triage becomes once a decision model replaces a full language model for sorting.
043. Analyze competitors' ads
- Tagging competitor ads by format, call-to-action, and funnel stage at scale turns a public ad library into a searchable swipe file instead of something nobody has time to read.
- A decision model made tagging 54 ads from three brands take about a second and a half for under a cent, cheap enough to run continuously instead of as an occasional manual audit.
054. Find the best clips in long videos
- Scoring every moment of a long recording for clip-worthiness turns hours of manual scrubbing into a six-second pass that still leaves the final top-10 pick to a person.
- Clip-finding tools built this way let you record once and get a short list of the strongest moments back, rather than editing being the bottleneck on publishing from long-form footage.
065. Score and profile your customer base
- Grouping customers into health, attention, and at-risk buckets from existing account data flags who to reach out to before they cancel, not after a cancellation notice arrives.
- The same categorization pattern, point a decision model at data you already have, works for churn risk just as well as it does for support tickets or ad tags.
076. Build backlinks in a site or second brain
- Auto-linking related pages or notes to each other took a decision model two and a half seconds across 60 posts, a task tedious enough that most sites and notes never get it done manually.
- The same backlink trick applies to both a public website's SEO and a personal notes system, since both are really the same problem: connect related documents.
087. Find buyers in your comments
- Comments from buyers are usually already there, just buried, so tagging each one by intent (ready to buy, question, complaint) turns a noisy feed into a priority list.
- Automating comment triage means a seller stops manually scrolling hundreds of comments per post and instead gets the people closest to purchasing surfaced at the top.
098. Verify Jev's results
- Before trusting any automated categorization, run it against a validation set, a few dozen to a hundred examples where you already know the right answer, and count how often it agrees.
- Where a decision model gets things wrong on a validation set is exactly where to recalibrate its categories or prompt, rather than assuming accuracy without ever checking it.
119. Let Jev pick the right skill
- When an agentic platform has dozens of skills to choose from, letting a fast decision model pick the right one speeds up every prompt instead of making the main model search through options.
- Across a real test, a decision model picked correctly from 145 skills in about 5 seconds total versus roughly 30 seconds for a larger model doing the same job.
1210. Let Jev pick the right model
- Routing each incoming request to the cheapest model that can actually handle it keeps spend proportional to task difficulty instead of flat-rating every request to the most expensive model.
- This model-routing pattern isn't tied to one platform; it works anywhere you can intercept a prompt before it reaches a language model, not just inside one specific coding tool.
1311. Put Jev in front of your AI agents
- Filtering a large inbox by what kind of message each one is, before a bigger model ever reads it, cuts both the volume reaching the expensive model and the resulting bill.
- A real test sorted 1,700 emails for 18 cents, tagging spam, replies-needed, and brand deals, which shows how much of a typical inbox doesn't need a full language model to process.
1412. Build Chrome extensions
- A fast yes/no model is well suited to anything that has to make a judgment call on every item in a feed, like filtering low-quality posts out of a social timeline in real time.
- The same filtering pattern, ask a cheap model one yes/no question per item, generalizes to hiding ads, cookie banners, or any other per-item decision across different pages and platforms.
1513. Search by meaning
- A fast decision model can match a loose, meaning-based query against page content well enough to feel real-time, a meaningfully different experience than literal keyword search.
- Splitting a page into chunks and having a model pick the best-matching one is a pattern that scales to any search box, not just the specific example shown.
1614. Search your images by what's in them
- Searching assets by what's actually in them, not the filename, requires some written metadata first; a cheap captioning model can generate that metadata for about 50 cents per thousand images.
- The constraint on content-based search isn't the search step, it's having any text description of each asset to search against in the first place.
1715. A live checker for what people say
- Because a decision model answers in a fraction of a second, it can score or categorize spoken content live, as it's being said, not just after a recording is finished.
- Real-time tagging of a conversation into decisions, action items, risks, and questions produces usable notes during a call instead of requiring a separate transcription-and-summary pass afterward.
1816. A chatbot with zero LLM calls
- A narrow chatbot can answer from a fixed, pre-processed dataset using only a decision model, without ever calling a full language model, as long as the question space is bounded.
- This pattern only works when there's already a structured dataset to match against, so it fits narrow, already-organized knowledge bases, not open-ended Q&A.
1917. Smarter designs for apps
- Picking the right icon or visual asset for whatever a user just typed is a selection problem, not a generation problem, which favors a decision model over a costlier language model or a brittle keyword match.
- A decision model is pitched here as replacing two worse options, an expensive general model or a regex-based matching system, each with its own downside of cost or missed matches.
2018. Web pages that build themselves
- A decision model can't write the components of a page, but it can choose which pre-built pieces to assemble for a given visitor, keeping page-load speed close to normal.
- Personalizing a page per visitor becomes viable at scale once assembly is just a selection problem among existing parts, not a generation problem that would add real latency.
2119. Finding your own Jev use cases
- The fastest way to find your own use cases for a new tool is to hand a capable model your own context, business details or past work, and ask it to point out where the tool would have helped.
- Reviewing past work for moments a cheap, fast decision would have sufficed is itself a repeatable audit, a way to keep finding new automation opportunities after the obvious ones are used up.
Terms worth knowing.
- Jev
- A decision-only AI model that can't write sentences but can pick true/false, a category, or a score from a fixed list almost instantly and at a fraction of the cost of a general-purpose language model.
- Decision model
- A model built to select from a predefined set of answers rather than generate free-form text, trading creative flexibility for speed and low cost.
- Validation set
- A batch of examples where the correct answer is already known, used to test how often an automated classifier agrees with a human before trusting it in production.
- Confidence score
- A number a model attaches to its own answer indicating how sure it is, used to set rules like routing low-confidence cases to a human.
- Model routing
- Automatically sending a request to whichever AI model fits the job, for example a cheap model for simple lookups and a larger model for complex reasoning.
Things they pointed at.
09:09toolGemini Flash-Lite
08:03toolUnclutter (Chrome extension)
05:38productRoboNuggets community
13:22productOpenAI Decisions API
Lines you could clip.
00:00
“Jev is the new AI model that everyone's building with right now, and for a good reason, because it can be up to 200 times faster and 400 times cheaper than other models.”
01:01
“Jev is a decision model, which means it can't write a sentence, but it can pick true or false, a choice from a menu or a score.”
07:50
“Your agent reads less and your bill for tokens also drops.”
13:20
“Even if you don't end up using Jev itself for any of these use cases, getting good at this way of building makes sense now.”
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.
Jev is the new AI model that everyone's building with right now, and for a good reason, because it can be up to 200 times faster and 400 times cheaper than other models. And so if you know exactly where to use it and how to use it, then it can definitely make your setup cheaper, make your systems faster, and ultimately transform your workflows.
So today I'll give you 19 use cases you can do with Jev, along with the prompts to get you started with your builds, so that by the end of this, you'll for sure have an idea of how to best use it. We'll start with the easy ones you can try today to some more advanced ones that can truly change how you build. And by the way, if you need a quick primer on what Jev is, I'll link a previous lesson I did somewhere in this video that goes through it in just a few minutes.
And if you're new, my name's Jay. I spent over a decade working with brands you probably know, have been in AI since my master's in data science, and now I'm leading our AI business in one of the largest AI communities globally. But for now, let's dive into it, starting with the easy ones.
Number one is to put Jev in Google Sheets. fast Jev is, is inside a spreadsheet. Jev is a decision model, which means it can't write a sentence, but it can pick true or false, a choice from a menu or a score.
And it does that in a fraction of a second for almost nothing. So if you have data in a sheet that needs categorizing, like a bank export, you can have Claude build you a plugin where you type a new column name, say category, and Jev fills in every row while you watch. It does this really quickly, and because Jev can only pick from your list, it never invents a category that you didn't ask for.
Here's a prompt to get you started. Number two is a triage customer inquiries. If you get a lot of customer questions, the first job is deciding what to do with each one.
Specifically, which one can an automation handle and which one needs a real person. So what you can do is to build an automation workflow where Jev is the decision layer instead of paying for a big language model to read every single message. Jev tags each inquiry.
Let's say if it's for billing or if it's a bug. or if it's a question, and it also tells you how sure it is. So that confidence score, that is the useful part.
Because if you set a rule for that confidence score, like for example, if Jeff is less than 60 % sure, let's say, you can just have a rule where Jeff sends that straight to a person. Then you can just adjust that confidence number threshold as you learn what works best for your business. In one independent test, 217 customer call transcripts were sorted into categories by Jev in 13 seconds for only 7 cents, which is really cheap and can really speed up your customer handling workflows.
And by the way, I've put every use case in this video into this free PDF guide, which you can just send it straight to your agent and start building. The link for that is in the description below if you need it. Number three is to analyze your competitors' ads.
The meta ad library shows every ad your competitors are running, but nobody reads hundreds of them by hand. So you can have Claude build you a plugin or a Chrome extension that does it. It saves each ad for you.
And Jeff reads the text very quickly on every ad and tags it. What's the format? What's the call to action?
What is the funnel stage? Then everything can land in a database. So you end up with a swipe file of what's working in your market.
When I tried it, Jeff tagged 54 ads from three different brands in about a second and a half for less than a cent. Number four is on clipping. If you make long videos or podcasts, finding the moments worth turning into shorts can take hours if you do it manually.
So what you can do is to build a clip finder where when I tried it out, it scored 411 possible clips from a 70 minute interview in six and a half seconds. Then it also picked the top 10 that is worth posting. So you can just record once and Dev would then hand you a short list of the best moments within that long form video.
Number five is to score and profile your customer base. If you run a software as a service platform, you already have a database of your customers, how long they've been with you, whether they're on an annual plan, whether they've started to cancel. Jeff can read all of that and put each customer in a group, like which ones are healthy, which ones need attention, or at risk of churn.
So instead of finding out when someone cancels once it's late, you already know who to reach out to this week. Number six is to build backlinks inside your website or your second brain system. This one is for anyone with a huge website or a big workspace where your agents are working in.
If you have a site, you want your pages linking to each other because it helps people find their way around. And it also helps a bit with your SEO. And if you have a second brain system, which is basically a huge folder of notes, the same links would help your agents find their way around it.
When I tried it on 60 test blog posts, it took only two and a half seconds to link those pages together. And the exact same trick would also link up your notes. So your second brain system would connect itself instead of a that to a big language model to do that for you.
Number seven is to find buyers in your comments. If you sell on social, your buyers are already in your comments, but it's just buried between everything else. Take a seller account on TikTok, for example.
Every video they have brings hundreds of comments. And what you can do is to pull those comments through a scraping tool like Appify, for example, then have Jeff automatically tag each one, which ones are ready to buy, which one is a question, which one is a complaint. So instead of manually scrolling through your comments, you would then get a priority list with the people ready for you to buy right at the top.
Number eight is about verification of Jeff's results. Before we go to the rest of the use cases, one of the things you should learn is how to verify if Jeff's categorization is correct for you. One way to do that is through what's called a validation set, which is just a few dozen or 100 examples, depending on your use case, where you already know the right answer or where a person already did the sorting by hand.
So what you essentially do is you run Jev on that set without showing it the answers first, then count how often it matches. You then look at where Jev got things incorrectly, because that is where you can calibrate the model to be more correct next time. So those are the easy ones and you can see the pattern there is basically you point Jev at a pile of stuff you already have and you just have Jev categorize those at lightning speed.
Now let's get to some of the more intermediate use cases. And by the way, if you want to learn how to build and sell AI systems that businesses actually pay for, then that's pretty much all we do over at the RoboNuggets community, where not only do you get access to the Cloud Living Masterclass, which we update every week and takes you from zero to mastery with the latest on AI, but you also get access to our Agents as a Service course, which walks you through how to actually get paid for all these AI skills that you are learning.
You also get to be part of a genuinely great community of AI builders. In fact, you can see just some of the recent wins our members are getting from the program right here. So if you want to start earning from AI, then check that just in the pinned comment below.
Now back to the video. Number nine is letting Jev pick the right skill. If you use Cloud Code or another agentic platform, you probably have dozens of skills.
And Cloud sometimes takes a lot of time to load the right one. So what you can do is let Jev pick it. Once your prompt goes in, your skills basically becomes the menu of options.
And Jev would pick the right one at really fast speeds. In my own workspace, I have something like 145 skills. And across 14 tests, Jev found the right skills in about 5 seconds in total, while Opus 5 took around 30.
The company behind Jev, TypeSafe, also tested this with 182 skills, and it cut the wrong picks by more than half. Number 10 is to let Jev pick the right model. So this is the same idea, but for model routing.
So what you can do is to make a slash jev command in Claude, and when this is on, Jev would read every message that you send and pick the model for it in about a third of a second. So for example, when I asked it to find a file path, Jev handed that to a haiku helper, which is the cheapest model in Claude, instead of Opus.
And when the job is hard, it goes to the bigger model. So you only pay for the big model when the job actually needs it. And this same model routing idea works even if you are not using Claude.
That also works in Codex or other agentic platforms. Number 11 is to put Jev in front of your AI agents. If you have an AI agent answering your emails like these, you're paying a big model to read every single one, which includes even spam.
So what you can do is put Jev in front of it. In one test, Jev sorted 1700 emails for 18 cents, where Jev tagged what needs a reply, what's a brand deal, and even what's a scam or spam. Then only the ones that actually need writing or replying go to Claude.
So your agent reads less and your bill for tokens also drops. Number 12 is to build Chrome extensions. You can also build Chrome extensions using Jev.
And one fun example I saw is about cleaning up your X feed. Someone built one that checks every post as it loads, and Jev answers one question, if this is AI slop or not. If it is, the post gets folded away, so what's left is the stuff that is worth reading.
The same trick works anywhere, by the way, where there's a feed, like for example, LinkedIn or any page. Or let's say if you want to build an extension where you want to hide the ads and cookie banners in a page. like this Chrome extension called Unclutter.
So you can launch plugins like these that reshape what you see in the web using Jev. Number 13 is search by meaning features. Now, when you do control F, that only finds usually the exact words that you type.
But with Jev, you can actually build a find feature where you type roughly what you're looking for, and it would highlight the right part of the page. even when the words don't match. It would split the page into paragraphs, asks Jev which one matches best, and scrolls straight to it.
It's fast enough to feel real -time, so if your app or your website has a search box, this is one of the easiest upgrades that you can give it. Number 14 is a related one, which is searching your images by what is in them. In my workspace, I generate a lot of images and videos, and searching them by file name barely works.
So what I built is a search powered by Jev, where typing keyword, let's say Claude, would find the images that are actually about Claude, not just the ones with Claude in the file name. The one thing you need, though, is some written words about each image, which we call metadata.
In my case, I log the prompt for every image that I generate, and so that is my metadata. But if you don't have that, a really small, cheap model can write a short caption for each one. What you can try out is Gemini Flashlight, because captioning a thousand images costs about only 50 cents.
So those are the intermediate ones, and they already make your setup faster and cheaper. Now let's go to some of the advanced ones. Number 15, a live checker for what people say.
Because Jev answers in a fraction of a second, it can check what people say while they're still saying it. Someone actually built a live BS meter called Jev Meter, which scores every sentence of a debate as it's spoken. You can also build a plugin, let's say, for your meetings, where every sentence gets sorted as it is set into decisions, which ones are action items, which ones are risks, and which ones are questions.
So if you're on a sales call, you'll get easy notes to recap as you go, and it works for interviews and even podcast conversations as well. Number 16 is a chatbot with zero LLM calls. This one sounds implausible, a chatbot that never really calls a language model, but here's how it can work.
In this demo app, you can ask which of our lesson teaches a certain topic. Let's say the person is curious about Jev as a topic. In the back end, Jev the model then quickly answers that in real time because it has access to a list of my videos that are already pre -transcribed, informing Jev of what each video is about.
So if you need a narrow chatbot that can answer things quickly from a given dataset, like video transcripts in my case, or even company documents in most corporations, then Jev is a potential tool for that. Number 17 are smarter designs for apps. Here's a simple example for apps that rely heavily on visuals like icons.
When a user types something, Jev can pick from a given set of icons. So let's say in a habit tracker, you type drink more water and it picks the water icon for you. In a mood app, you write how your day went and it picks a custom mood icon.
A designer actually showed this off where as he's typing, Jev is pulling up the icons relevant to that text. And the thing is before Jev, to do this effectively, You need either an LLM, which can be costly or at least much costlier than Jev, or to build out something like a Regex -based matching system, which is sometimes not as effective versus a language model.
But with a decision model like Jev, this can be done for so much faster and for so much cheaper. Number 18 are web pages that build themselves. Now, Jev can't write code, but it can pick parts.
Someone actually built a demo where Jev would get a library of ready -made pieces like forms, buttons, sign -in boxes, and fonts, and it decides what each visitor needs and puts the page together on the fly. And the page shows up about as fast as a normal page load because Jev is only choosing parts and not actually building them.
So every visitor could get a page that's built for them in real time. Number 19 is about finding your own Jev use cases. This last one is a bit of a meta use case because you can actually use Jev to find your own use cases.
There's a site called shipwithjev .com, which lists Jev use cases by category. So what you can do is to open cloud based in that site, along with a file about yourself and your business, and just ask based on everything you know about me, which of these use cases would help me the most. You can then ask cloud to use Jev in order to categorize which of those use case are more.
useful so you get a starting point another option is to ask claude to look back over your past sessions and actually point out the steps where a quick jev call would have done the job that way you would find use cases in the work that you are already doing so there you go that is all of them And as a final note, OpenAI, in their Dev Day a few days ago, actually just launched their Decisions API, where you give it a question and a list of allowed answers, and it picks one in about 150 milliseconds.
And the reason why that's familiar is because that's basically their answer to Jev. And the point I'm making is, even if you don't end up using Jev itself for any of these use cases, getting good at this way of building makes sense now, because for sure, the other big labs, starting with OpenAI, probably Entropic 2 in the future, will be copying something like this.
As usual, thanks for watching till the end. Again, the free PDF guide with every prompt and resource from this video to get you started is just linked in the description. And I'm curious, like which of these would you build first?
And do you have other use cases in your company that I haven't covered yet? Let me know down below and I'll see you all next time. Cheers.
The Hook
The bait, then the rug-pull.
Jay opens with a stat hook, a new decision-only model that's up to 200 times faster and 400 times cheaper than a normal language model, then spends fourteen minutes walking through nineteen concrete ways to pair it with Claude Code, from spreadsheet categorization to email triage to picking which Claude skill or model should even handle a given prompt.
Named ideas worth stealing.
05:04concept
Validation-Set Calibration Loop
Run the decision model on a set of examples with known answers, count how often it matches, then study the misses to recalibrate categories or prompts before trusting it in production.
Steal forany classification or triage automation before it goes live
01:49concept
Confidence Threshold Routing
Have the model attach a confidence score to each decision, then set a rule, for example anything under 60% sure, that automatically routes uncertain cases to a human instead of letting the automation guess.
Steal forany AI triage system where a wrong auto-decision is costly
How they asked for the click.
VERBAL ASK
13:07link
“The free PDF guide with every prompt and resource from this video to get you started is just linked in the description.”
Repeated three times (intro, mid-video, and sign-off) as a low-friction lead magnet, a downloadable PDF of all nineteen prompts, rather than a single end-screen ask.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
AFFILIATECommission earned if you click.
