Jev + Claude = INSANE Results (Every Concept Explained) — Transcript
Full transcript
- 0:00The most talked about AI model this
- 0:01month can't even write a sentence. You
- 0:03can't chat with it, and it can't explain
- 0:05itself. And this is what people built
- 0:07with it in the first week it was
- 0:09released. We've got a browser that fills
- 0:10in Google Flights in about 7 seconds.
- 0:12And if you've ever tried to use Claude
- 0:14with a browser, by the way, you'll know
- 0:15that it's incredibly slow. We've got 3
- 0:17million website sessions capturing lost
- 0:20customers, abandoned checkouts, and more
- 0:22sorted in 40 seconds for about $2. And
- 0:25then we've got someone else driving
- 0:26Chrome with their voice, where it even
- 0:28takes actions before they finished their
- 0:30full sentence. So, it's called Jev, and
- 0:32I've been through all the official docs
- 0:34so that you don't have to. And by the
- 0:36end of this, you'll know what it is, why
- 0:38it matters if you use Claude already,
- 0:40how to run it from Claude code and ask
- 0:43it the right questions, as well as how
- 0:45to get the most out of it. So, let's
- 0:47start by talking about what's different
- 0:48about Jev, because some of this isn't
- 0:50new. So, every piece of software you
- 0:53already use is already full of if
- 0:55statements. For example, if an order is
- 0:57over $10,000, we're going to flag it for
- 0:59review. The catch, though, is that an if
- 1:01statement can only check things a
- 1:03computer can measure. So, we're
- 1:04comparing it to a number, a date, a tick
- 1:06box, a criteria. But, it can't check
- 1:08whether an email sounds angry or whether
- 1:10an order looks dodgy, because those
- 1:12aren't numbers. They aren't checkable
- 1:13things. They're not deterministic. So,
- 1:14Jev is doing exactly that. It's turning
- 1:16those messy inputs from customers into
- 1:19numbers. So, the if statement then
- 1:20becomes, "If this order looks
- 1:22suspicious, okay, we're 95% sure, flag
- 1:25it for review." So, now it can be read,
- 1:27and a decision can be made by a
- 1:29computer. And we'll talk about how you
- 1:30determine what counts as suspicious,
- 1:32because we're going to use Claude and
- 1:33you to write the questions, and you are
- 1:35going to set the criteria for yes, the
- 1:3795% confidence level, for example. So,
- 1:39we're going to send a bunch of questions
- 1:40to Jev. Jev is going to answer each one
- 1:42with how sure it is, and your code only
- 1:45flags the order when all of them come
- 1:47back above that threshold that you've
- 1:48chosen, so that 95%. And this might feel
- 1:51a little bit different to your
- 1:51traditional LLMs, like your Anthropic
- 1:54chat models. And that's why Type-Safe,
- 1:56the company behind Jev, call it a
- 1:58judgment model. So, it was built by a
- 1:59founder, Diogo, who helped build the
- 2:01methods behind ChatGPT at OpenAI. So,
- 2:04this is a massive announcement. And if
- 2:06you compare it to something like Claude,
- 2:07on the surface, you can absolutely ask
- 2:09Claude, "Does this order email look
- 2:11suspicious?" And you're going to get a
- 2:12text response from Claude like, "You're
- 2:14absolutely right. This does look
- 2:16suspicious. Would you like me to draft
- 2:17an email to the customer?" It's going to
- 2:18take about 10 to 15 seconds to get to
- 2:20that point. Versus Jev, on the other
- 2:21hand, who's given a bunch of questions
- 2:24to look for up from. The answers to
- 2:25those questions are going to determine
- 2:27how suspicious it actually is. Like, is
- 2:29there an address mismatch between the
- 2:31billing address and the delivery
- 2:32address? And then it's given the
- 2:33information it's actually processing.
- 2:35This is called the state, and in this
- 2:37case it would just be the individual
- 2:38order email that we're assessing. And
- 2:39then the response from Jev is not going
- 2:41to be a text response. It's only ever
- 2:43going to give you a number from the
- 2:44options that you've defined. And the
- 2:46number is going to tell you the
- 2:46likelihood of it being suspicious
- 2:49against the criteria that you defined.
- 2:51So, it's never going to write an output
- 2:53like Claude. And there are certain
- 2:54advantages to this that we'll cover in a
- 2:56moment. And this is totally different
- 2:57from the chat interfaces that we're used
- 2:59to when we see things like LLMs, large
- 3:01language models. This is closer to these
- 3:03deterministic machine learning models
- 3:05that is another style or type of AI. And
- 3:07Type Safe specifically call this what
- 3:09they call a system one model, after the
- 3:11book Thinking Fast and Slow. And system
- 3:13one is basically a quick name for a fast
- 3:15gut call. Where system two is sitting
- 3:17down and working out the reasoning,
- 3:19right? So, Claude, ChatGPT, and every
- 3:21other reasoning model are system two,
- 3:23but Jev sits in system one. So, why is
- 3:25it so special then compared to
- 3:26everything else that we've seen today
- 3:28with our traditional LLM chat models?
- 3:31So, there's a few reasons why not
- 3:32writing as the output is advantageous in
- 3:35some use cases. Firstly, it's cheap and
- 3:38extremely fast. So, it's suggested that
- 3:40it's 42,000 times cheaper than
- 3:42traditional LLMs and 20 to 400 times
- 3:45faster. It's about 4 cents per million
- 3:48tokens in, and the output is practically
- 3:51free. The second reason it's
- 3:52advantageous is it can't make up an
- 3:54answer. So, if you give it three
- 3:55options, it comes back with one of those
- 3:57three options every time. So, this is
- 3:59actually a pro and con, which we'll come
- 4:00to later in the specific rules that you
- 4:02need to give Jev when you're operating
- 4:03with it. The third advantage then is it
- 4:05that gives the same answer or almost the
- 4:07same answer twice in a row. So, it's
- 4:09much more consistent than LLMs in
- 4:11answering the same question over the
- 4:12same data set. So, the same test, they
- 4:14ask the same questions over and over,
- 4:15and the answers or the output from Jev
- 4:17moved less between runs than any of the
- 4:20chat models they tried. Even with the
- 4:21prompt set to be as repeatable as
- 4:23possible with the other models. And then
- 4:24the entire point of this is the number
- 4:26that Jev gives you as the output makes
- 4:28something that's usually uncertain, like
- 4:31a fuzzy customer email that's messy,
- 4:33it's got lots of text, and it makes it
- 4:35actually usable by software. So, Type
- 4:37Safe have trained this model so that the
- 4:38probabilities are calibrated. So, in
- 4:40plain English, it basically means it
- 4:42works like a weather forecast. So, when
- 4:44Jev says 0.8 is the output, it should be
- 4:46right about eight times out of 10. And
- 4:48based on that eight times out of 10 or
- 4:49the confidence in the output, that's
- 4:51what lets the software decide whether to
- 4:53act on it or not, whether to route that
- 4:54query somewhere else. The next actions
- 4:56are decided based on that number, and
- 4:58Jev gives you the probability of that
- 5:00specific question being true or false.
- 5:02And we'll see the different types of
- 5:03options we're able to give to Jev in a
- 5:05little while. Compare that to a chat LLM
- 5:07model which are trained to sound right
- 5:10to a specific person, and that's why we
- 5:11have that bias where it agrees with
- 5:13everything we said. Jev is not built in
- 5:15the same way. Now, super important, if
- 5:17you already use Claude or something like
- 5:19GPT, it does not replace it. It's going
- 5:22to work alongside it, and it's going to
- 5:23add advantages to certain workflows. So,
- 5:25Jev replaces one entire category of work
- 5:28that Claude does today. And whenever I
- 5:30say Claude, you can, you know, replace
- 5:31that with any of the LLM providers that
- 5:33you want here. And that category of work
- 5:35is going to be the fast decisions that
- 5:37we need to make in bulk inside software.
- 5:39So, the code that you're going to pass
- 5:40to Jev hands Jev that information, like
- 5:43our customer email, and a set of tightly
- 5:45defined questions which we want to know
- 5:46the answer to, and Jev is going to send
- 5:48back a probability, a category, or a
- 5:50score. And then your code, off the back
- 5:52of that, is going to use that to route
- 5:54it, to rank it in order, to flag it to a
- 5:57human, or to carry on. So, it's going to
- 5:59take actions off the back of that
- 6:00potentially. But, everything that needs
- 6:02a conversation, a chat back and forth,
- 6:04or reasoning, or writing is still going
- 6:06to stay within our Claude interface. And
- 6:08Diogo, the founder, specifically said on
- 6:10the Latent Space podcast that Claude is
- 6:12the conversation, and Jev is the
- 6:14plumbing underneath that. And it's
- 6:16important to actually reflect on the
- 6:17fact it cannot do everything, and in
- 6:18fact, it can do very few things. But,
- 6:20the things that it can do, it can do
- 6:22them really, really well. So, we
- 6:24mentioned earlier that each question it
- 6:25answers can be split into one of three
- 6:27types. Now, let's run through each of
- 6:29those types using that angry customer
- 6:30example again for ease. So, first, we
- 6:33have yes-no questions. These are called
- 6:35a null, and this might be, "Does this
- 6:37customer sound angry?" Let's say Jev
- 6:39gives us a 0.9 back. So, it reckons it's
- 6:42a 90% chance of yes, this customer is
- 6:44angry. And then your code, your script,
- 6:47important to note this isn't Jev, this
- 6:48isn't your LLM, it's a script that we
- 6:50can get Claude to write, then does the
- 6:52rest with a normal if statement. So, if
- 6:55the result is above, let's say 0.8,
- 6:57we're going to escalate that to a
- 6:58manager. So, the manager can then
- 6:59directly respond to that customer. Or if
- 7:01it's below 0.2, i.e., they're definitely
- 7:03not angry, or Jev has deemed them
- 7:04definitely not angry, then we're not
- 7:06going to escalate it, we're going to
- 7:07deprioritize it. But, it's important to
- 7:09understand that Jev never actually
- 7:10escalates anything, it just gives you
- 7:12the number, which represents the
- 7:14probability of it being a yes in this
- 7:16case. Where 0.9 is a confident yes, the
- 7:18customer is angry, and 0.5 means it has
- 7:20no idea, it's like a coin flip. And then
- 7:22the code or the script is going to take
- 7:24the decision based on that number it
- 7:25gets back. The second type we can give
- 7:27it is called a choice. It's exactly as
- 7:29it sounds. You give it categories that
- 7:31you predefine, and in the angry customer
- 7:33case, it's like, "Which team should
- 7:34handle this query? Should it be billing,
- 7:37technical, sales?" And it's going to
- 7:39come back with a probability for every
- 7:40single one of those options. It's not
- 7:42going to say yes, it's billing. Yes,
- 7:43it's sales. It's actually going to say
- 7:45billing was an 85% chance of being
- 7:47correct. Technical was a 10% chance.
- 7:50Sales with a 5% chance. And the code off
- 7:52the back of those results is then going
- 7:54to route the email to the winner. So in
- 7:56this case it's going to be billing. So
- 7:57you're going to use choice when you're
- 7:59routing the output somewhere. And when
- 8:01the options do have an order, we're
- 8:02going to use the third type, which we'll
- 8:03talk about in a second. Now because
- 8:05we've got more than one option there,
- 8:06we've got billing, technical, and sales,
- 8:08you actually get a second number
- 8:09returned by Jev called confidence. And
- 8:11that's worked out from how spread out
- 8:13those probabilities are. So the 85% for
- 8:15billing is confident. But let's say
- 8:17billing was at 40, technical at 35,
- 8:19sales at 25, then we're less confident
- 8:21about that or Jev is less confident.
- 8:23Billing is still going to be the chosen
- 8:24one, but the confidence is going to come
- 8:25back low. And that's the number your
- 8:27code is going to check before it trusts
- 8:28that pick in the first place. So it's
- 8:30going to check that confidence number
- 8:31too. And that's exactly what the browser
- 8:32demo that we showed at the start is
- 8:34doing. Every button and box on that page
- 8:36for the flight booking is going to get a
- 8:37number. And Jev answers two choices at
- 8:40once. What to do with it? So do we
- 8:42click, type, or scroll based on the
- 8:45action or the input from the voice? And
- 8:46which number to do it to? And we've
- 8:48basically ordered everything on the page
- 8:50to get a number. And we're going to pick
- 8:51element three or four or seven. And
- 8:53there's no order to either of those. And
- 8:55so we know that this type is going to be
- 8:56a choice. And the confidence then is
- 8:58going to be that safety catch. So if Jev
- 9:00is confident, i.e. puts it above that
- 9:02confidence level, then the click is
- 9:04going to happen. With below it, the
- 9:05agent is going to stop and ask the user.
- 9:07And you can raise or lower the threshold
- 9:08for confidence and what is acceptable
- 9:10based on a specific action. If it's
- 9:12something that's going to be detrimental
- 9:13or highly costly, then we need a higher
- 9:15confidence level to permit an action or
- 9:18a higher safety catch effectively. And
- 9:20the third one then is a score. So it's
- 9:21the same idea as choice, but the options
- 9:23have an order to them. And you describe
- 9:25each one in words. So the question might
- 9:26be how angry is this customer? And the
- 9:29results are going to be a score. And the
- 9:30score is going to be between calm,
- 9:32annoyed, and furious. Those are the
- 9:34three options. So Jev is going to come
- 9:35back with a position on that scale
- 9:37between calm, annoyed, and furious. And
- 9:39it can actually land between the two
- 9:40levels. So, 2.4 out of 3 means they're
- 9:42mostly annoyed because that was the
- 9:43second option, but they're edging
- 9:45towards furious. So, when we're sorting
- 9:46an entire inbox of customer service
- 9:48emails, we can actually rank them. And
- 9:50this is what our code does or our
- 9:51script. The inbox by the worst first.
- 9:54So, the three out of threes on top, the
- 9:55null out of threes or one out of threes
- 9:57right at the bottom. So, you'd use the
- 9:58score then on anything you'd put on a
- 10:00scale. This is why it's important
- 10:01between choice and score that there is
- 10:03an order to things here. So, it's like
- 10:05how urgent is this ticket? How good a
- 10:06fit is this lead for what we actually
- 10:08sell? How senior is this candidate on
- 10:10this scale? How bad is this bug? Is it
- 10:12cosmetic bug? Is it an annoying bug? Or
- 10:14is it a blocking bug for somebody taking
- 10:16an action on our page? So, use it when
- 10:17you want to rank or sort and not root a
- 10:20response necessarily like choice. And
- 10:22because it's got several different
- 10:23levels, it also comes with a confidence
- 10:25the same as choice does, but null does
- 10:27not come with a confidence. It's either
- 10:28yes or no. So, the website session demo
- 10:30I showed at the start of the video is
- 10:31mostly that first type, a yes or no per
- 10:34event. Was this person rage clicking?
- 10:36Was this person dead clicking? Did
- 10:38something error on the page? Then we
- 10:40actually add this score as a layer on
- 10:42top of that. So, how bad was this whole
- 10:44session for this user? So, that when
- 10:46we're sorting those sessions, we can
- 10:47come back and actually sort them from
- 10:49worst first, and a person then can only
- 10:51open up the top 10. Now, you can of
- 10:53course do this whole process in a large
- 10:55language model, but it's not optimized
- 10:57for making these probabilistic
- 10:58decisions, and therefore we can do an
- 11:00astounding amount of them in a very
- 11:02short space of time for very, very
- 11:04cheap. And the way to choose between
- 11:06these three different methods, the null,
- 11:07the choice, or the score, is working out
- 11:10what your code does with the answer
- 11:12afterwards. So, if it needs to act or
- 11:14not act based on the answer, that's
- 11:15going to be a yes or no or a null. If it
- 11:17needs to root the response somewhere,
- 11:18that's going to be a choice. Or if we
- 11:20need to sort or rank by it, then that's
- 11:22going to be a score. And most
- 11:23importantly, all three of these types
- 11:24can actually go into one request to Jev.
- 11:26So, here's an example of one email going
- 11:28in with all three questions attached,
- 11:30and this is what comes back. So, we've
- 11:32got a null first, a question that says,
- 11:33"Does this customer sound angry?" We've
- 11:35got the null 0.9. So, basically it's
- 11:36saying for the code to escalate this to
- 11:39a member of staff. Then we've got the
- 11:40choice, which team is this? And it says,
- 11:42"Billing is 85 likely, technical 10,
- 11:44sales five." And we've got a high
- 11:46confidence level. So, it's going to
- 11:47route to the billing team. And then the
- 11:49score, how calm, angry, annoyed, or
- 11:51furious on a scale of four here. And
- 11:53we've got a 2.4 with confidence of 80%
- 11:56or 0.8. So, it's going to go near the
- 11:58top of the pile for the emails that the
- 11:59billing team are going to answer. And
- 12:01they're only going to see the ones where
- 12:02the customer actually sounds angry. So,
- 12:04they've got a short list of answers
- 12:06because Jev has actually processed a
- 12:07huge amount that don't need to go to a
- 12:09customer service rep. So, we've got one
- 12:10email in, but three answers out in a
- 12:12very, very short space of time. So, now
- 12:14let's move on to how to actually pair
- 12:16this with Claude code so that you can
- 12:18use both tools to their full advantages.
- 12:20But first, I'm about 1,000 subs from
- 12:22that magic 100k and that plaque on my
- 12:25wall. So, if you're enjoying this so
- 12:26far, make sure to sub down below. So,
- 12:28anyway, there's two ways to pair it with
- 12:30Claude to get the best out of both
- 12:31tools. And Type Safe are really clear in
- 12:33their docs about what it's bad at and
- 12:35therefore where you should use Claude.
- 12:37And that's reasoning, specialist
- 12:38knowledge, and anything that effectively
- 12:40needs writing. So, the first way in
- 12:42which you can pair it with Claude is
- 12:43actually using it around Claude's
- 12:45features for checking things. So, before
- 12:47Claude reads something, you're going to
- 12:49get Jev to decide whether Claude should
- 12:50actually read it, whether you should
- 12:51spend tokens on that thing. So, Type
- 12:54Safe use a guardrails example, which
- 12:56screens every single message that comes
- 12:58into Claude for jailbreaks and harmful
- 13:00requests on the way into Claude. It's
- 13:02then going to screen Claude's reply on
- 13:04the way out before the user sees it. So,
- 13:07that's a good example of Claude in the
- 13:08middle, but using Jev as guardrails on
- 13:10the before and after. And you can also
- 13:11use the same idea after the LLM
- 13:13processing. So, in their citation
- 13:14example, an LLM wrote a document with
- 13:16eight citations in it, and Jev checked
- 13:18each quote against the source. Four were
- 13:20found to be fine, one quote was a
- 13:23non-existent citation, and one said the
- 13:25actual opposite, and two were actually
- 13:26rooted to a person because Jev wasn't
- 13:28sure. So, that is like post-processing
- 13:30of Claude and LLM content gone through
- 13:32Jev to make sure that everything they
- 13:34were putting out was factually accurate.
- 13:36And the second way you can use it with
- 13:38Claude is actually using it instead of
- 13:40Claude for the bulk work, for the tasks
- 13:42that are larger in scale, but also very
- 13:45deterministic. So, don't use Claude to
- 13:47sort 5,000 rows, tagging every ticket in
- 13:49your inbox, scoring every single lead.
- 13:52Claude should only get the rows that Jev
- 13:53wasn't actually sure about or the ones
- 13:55that need something written. If it's
- 13:56that deterministic scoring, then we
- 13:58should use Jev instead of Claude for
- 14:00that stage in our workflow. And this is
- 14:02the one that you've probably seen all
- 14:03over X or Twitter. Here's someone
- 14:05scoring 700 sales leads in 40 seconds
- 14:08for around 9 cents. So, something that
- 14:10is bulk work would take significantly
- 14:12longer using Claude and also cost a lot
- 14:14more, too. And actually both of those
- 14:15examples we're going to build together
- 14:17in the next 5 or 10 minutes using a
- 14:18customer service example. So, let's get
- 14:20that set up inside Claude Code now. So,
- 14:23Type Safe actually shipped a skill for
- 14:25use in LLMs like Claude Code or
- 14:26harnesses like Claude Code, and it's two
- 14:28lines to install. So, you can either do
- 14:29this through the console once you've
- 14:31signed up on typesafe.ai,
- 14:33you can copy this agent prompt, or you
- 14:35can actually head to the
- 14:36docs.typesafe.ai/agent-skill,
- 14:39and you're going to run these two
- 14:40commands in your terminal to get it
- 14:42inside to Claude Code. And you can also,
- 14:43you know, take these commands directly
- 14:45from here or use it with other agents
- 14:46there, too. I recommend to actually use
- 14:48this that you need to make sure that you
- 14:49name the skill in your prompt. So, when
- 14:51you're sending a command to Jev, for
- 14:53example, we're going to say use the Type
- 14:54Safe skill, and you'll see that in all
- 14:56of our prompts. So, we're going to run
- 14:57those two commands. It's going to add
- 14:58the marketplace. We're then going to
- 14:59reload to make sure that the plugin's
- 15:01installed. And you can see that that's
- 15:02now a success. So, once we reload or
- 15:04load up a new session with Claude Code,
- 15:05we can run /plugins, and we can see, if
- 15:08we go to installed, that we've got the
- 15:10Type Safe plugin now enabled. You're
- 15:12going to head into the API key section,
- 15:14create a new key, and you're going to
- 15:15put that in a .env file under the name
- 15:17Type Safe API key. Then to check it's
- 15:19working, we're going to say use the Type
- 15:20Safe skill. That's really important.
- 15:22Check my key works. Ask Jev one yes or
- 15:24no question about and this is our input
- 15:27as if it's a customer email, right?
- 15:28We've been charged twice. Please fix
- 15:30this ASAP. And we're going to ask Jev to
- 15:32assess it on the question, the customer
- 15:34is reporting a billing problem, and to
- 15:36tell us the raw answer from Jev that we
- 15:38get back. So, with this, we should just
- 15:39get a yes or no in the form of a number
- 15:41that that deems is this a billing
- 15:44problem or is it likely to be a billing
- 15:45problem? Now, before we run the output,
- 15:47if you're not working in Claude code
- 15:48directly, and you actually want to work
- 15:49in the desktop app, I haven't tested
- 15:51this yet, but it should work exactly the
- 15:52same. All you need to do is go to find
- 15:55the skill.md on GitHub. You're going to
- 15:56open this page and then effectively
- 15:57download and upload the skills in the
- 16:00customize section inside your skills.
- 16:02So, you're going to add upload the file
- 16:03and then you should also have access
- 16:04inside the Claude desktop app to using
- 16:06Jev as well. So, let's run this prompt.
- 16:08We're going to use the type-safe skill
- 16:09and let's see what comes back. So, you
- 16:10can see here, this is the request based
- 16:12on the type-safe skill that it's
- 16:13actually determined. So, the state is
- 16:14the information we're sending, charged
- 16:15twice, please fix this ASAP. That's the
- 16:17email we're sending it to Jev latest.
- 16:19The question is, is it a billing
- 16:20problem? It's deemed that it's a yes or
- 16:21no and given it a descriptive
- 16:23instructions. So, the customer is
- 16:24reporting a billing problem, exactly the
- 16:26criteria that we wanted to assess
- 16:28against. The true criteria is the
- 16:29message reports a problem with charges,
- 16:31payments, invoices, refunds, or
- 16:32subscription billing. The false is the
- 16:34message does not report a billing
- 16:35problem. So, you can see that these are
- 16:37very descriptive criteria that Jev can
- 16:39therefore determine is a message or the
- 16:41state likely to be a yes or no against
- 16:44that criteria. Claude has created this
- 16:46criteria based on the type-safe skill.
- 16:48So, it's come back with an answer then
- 16:49and the answer from Jev was effectively
- 16:51this one number, 0.99, where one means
- 16:54it was absolutely a billing problem and
- 16:56zero means it was not a billing problem
- 16:58at all. You can see that this is the
- 17:00response that we get directly from Jev.
- 17:02The input tokens were 324 tokens. The
- 17:04output tokens were 24. I also asked
- 17:06Claude to extract the time it took as
- 17:08well as the cost. Jev's own share of
- 17:10that was 0.3 seconds and that's probably
- 17:12an overestimate based on the fact that
- 17:13Claude actually had to make the
- 17:15connection in the first place. And 324
- 17:17input tokens is effectively 0.0000136
- 17:21dollars. So, you can see how it could
- 17:22have done this for thousands of emails,
- 17:24and it barely scratched the surface on a
- 17:26couple of cents. You'd need 73,000 calls
- 17:28like this to spend a dollar. Extremely
- 17:30cheap, extremely fast. And then the 24
- 17:32output tokens, which was effectively
- 17:34just telling us the number, cost nothing
- 17:36to us. And by the way, if we jump back
- 17:37to what this skill actually does, the
- 17:39type safe skill, it doesn't actually run
- 17:41anything itself. It's basically a rule
- 17:43book that Claude can use or another
- 17:44agent can use with the three question
- 17:46types. So, it's able to determine which
- 17:47question type it should be in, how to
- 17:49write a question Jev won't misread. So,
- 17:51it's about specificity of a question,
- 17:53when to batch questions together versus
- 17:55when to keep them separate, and we'll
- 17:56cover that later, and where to keep the
- 17:58thresholds, the confidence levels. So,
- 18:00if you're working from Claude, you never
- 18:01talk to Jev directly. You describe the
- 18:03job in plain English. Claude is going to
- 18:05read the skill. Claude's going to write
- 18:06the scripts to assess it against, and
- 18:08the script is going to send your rows to
- 18:09Jev, and Claude is going to read you the
- 18:11results back. So, this is how you use
- 18:13them in conjunction. And alternative
- 18:15right is you could use something like
- 18:16Open Router, skip Claude code as a
- 18:18harness here, and directly use the model
- 18:21from Open Router, the Jev Lab model from
- 18:23Open Router. But that would effectively
- 18:24mean that actually you need to make up
- 18:25the questions, you need to make up the
- 18:27descriptions, you need to effectively
- 18:29structure that input to Jev there. So,
- 18:31you've seen now that the key works.
- 18:32You've seen it's really quick. You can
- 18:33see we can scale this up. So, let's
- 18:35actually deconstruct how you would use
- 18:37this for yourself using an example of 50
- 18:39support emails that come in overnight.
- 18:41So, I've got this CSV or Google Sheet
- 18:43here of 50 different support emails,
- 18:45when they were received, the ID of the
- 18:46email, when that customer has been a
- 18:48customer since, which plan type they're
- 18:49on, what invoice they last paid, the
- 18:51subject, the body. So, everything that
- 18:53we'd need to pass into Jev. We're going
- 18:55to deconstruct on exactly how you would
- 18:57turn this into a workflow that sorts
- 18:59them so that the easy ones are answered,
- 19:00the risky ones are sent to a member of
- 19:02customer support, and that when they're
- 19:03queued, they're actually in priority
- 19:05order so they're ranked when somebody
- 19:07sits down in the morning to read these
- 19:08customer service messages. So, these
- 19:10emails are in a emails.csv that we made
- 19:12earlier, but equally you could if you're
- 19:14using a harness like Claude code, use
- 19:15the MCP to plug this directly into your
- 19:17email inbox and process this in the same
- 19:20way. So, you can see we've got examples
- 19:21like "Hi, I've just seen two charges of
- 19:22$99. I signed up for a trial and the
- 19:24magic link never arrived." A feature
- 19:26request here, "Can you add perplexity to
- 19:28it?" Some customer complaints here like
- 19:30"Metrics haven't been shown." or
- 19:32"Metrics have gone down." Some questions
- 19:33about GDPR compliance. All of that is
- 19:36effectively data that we can go through
- 19:38and get Jev to assess extremely quickly
- 19:40against the set of questions. Now, when
- 19:41deconstructing it, the most important
- 19:44thing before we write a single question
- 19:46is to decide what the code should do
- 19:48with each answer. So, the answers we're
- 19:50going to get back from Jev, the
- 19:51probabilities, the numbers, should all
- 19:52be a trigger for an action. So, every
- 19:55question that we make should be a
- 19:57trigger to a specific action. And we're
- 19:59going to talk about how to work out what
- 20:00questions to ask in the first place, and
- 20:02that's why we're going to go through and
- 20:03deconstruct this step-by-step. And when
- 20:05we consider the different actions that
- 20:06we will take off the back of the results
- 20:08in this customer support case, we've got
- 20:10four different actions effectively.
- 20:11We're going to answer the email with
- 20:13Claude directly or draft it with Claude.
- 20:14We're going to put it in the engineering
- 20:16queue as something that's a bug that
- 20:17needs fixing. We're going to log it as a
- 20:19feature request for the future. Or we're
- 20:21going to escalate it or send it to a
- 20:22person. So, that's then what I need to
- 20:24give to Claude, the job I want it to do,
- 20:26the four different actions or routes it
- 20:28can take, and one instruction, which is
- 20:30"Show me the plan before you run
- 20:32anything." And therefore, we're going to
- 20:33see effectively the structured plan that
- 20:35it's going to send to Jev, and we can go
- 20:37through and read before we do this on a
- 20:39bulk set of data piece by piece what the
- 20:42questions are, what set of data it's
- 20:43going to run on, etc. So, let's talk
- 20:45about the prompt, and I've been quite
- 20:47specific here, but you can actually get
- 20:48Claude, like I did, to write a similar
- 20:51prompt for your exact use case. So,
- 20:52again, we've got "Use the TypeSafe
- 20:54skill." Very important. "I've got 50
- 20:56support emails in emails.csv." I'm going
- 20:58to save it in my downloads. "Every
- 20:59morning I want them sorted into four
- 21:00piles, and these are our four actions,
- 21:02right? Reply with Claude, engineering
- 21:03queue, send to person, etc. Each pile
- 21:06sorted with the angriest customer first.
- 21:08So, from that and using the type safe
- 21:10skill, it's going to understand the list
- 21:12of priorities and what questions we need
- 21:13to ask. And then it's going to
- 21:15understand that we need a scoring
- 21:16question to score it by, you know,
- 21:18anger, for example. And because I've got
- 21:19some idea of exactly what I want to
- 21:21understand for each, I've actually
- 21:22specified it here, but you can leave
- 21:24this open for Claude to actually
- 21:25determine the questions and criteria,
- 21:26too. But for each email, I want to know
- 21:28what it's about. So, this might be a
- 21:29choice, billing, technical, feature
- 21:31request, account, or none of those. And
- 21:32it's really critical you put none of
- 21:34those in there because if it's not one
- 21:35of those, then Jev is effectively going
- 21:38to just try and pick the most likely
- 21:40outcome. Whereas if none of those is in
- 21:42there, it effectively gives it an out. I
- 21:44want to know if they're asking for money
- 21:45back or a refund. I want to know if
- 21:46something is broken because therefore we
- 21:48want to send it as the action to put it
- 21:51in the engineering queue. I want to know
- 21:52on a scale, probably, how angry they are
- 21:54from calm, annoyed, or furious, so like
- 21:56one to three. And I want to know whether
- 21:57it's just something quite routine and
- 21:59standard, needs some judgment, or is
- 22:00unusual enough that a person should
- 22:01handle it. And then I've added some
- 22:03rules for what the code does or what the
- 22:05code should do. Claude's code is going
- 22:06to create the code that's going to
- 22:07process Jev's answers. Anything about
- 22:10money should go to a person, never
- 22:11Claude. And I basically want a high
- 22:13confidence level on that one. If Jev
- 22:14isn't confident about the category or
- 22:17the case is unusual, send it to a
- 22:18person. If the product is broken, so
- 22:20they can't use it, it should go to
- 22:21engineering. Feature requests are
- 22:23getting logged. Everything else Claude
- 22:24drafts a reply using a a given reply
- 22:26guide, a separate brand resource,
- 22:28effectively. And we're going to sort
- 22:29every pile by a priority score that's
- 22:32mostly anger, partly severity. So, it
- 22:34needs to score based on multiple
- 22:36questions. And Claude, working with the
- 22:38type safe skill, is going to understand
- 22:39that it needs to break these down into
- 22:41individual deterministic or more
- 22:43deterministic questions that Jev can
- 22:44then give us a probability score on and
- 22:46a confidence score on. And then we
- 22:48specified this because we want to do an
- 22:49extra check. So, before any Claude draft
- 22:51is saved, check it with Jev in another
- 22:53request, a separate request, asking
- 22:55different questions against these
- 22:57questions. Does it actually answer the
- 22:58customer's question? And does it promise
- 23:00a refund or discount? So, we're doing an
- 23:01extra validation pass after Claude
- 23:05for the ones that are going to be
- 23:06written by Claude. And then we're only
- 23:07going to keep drafts that pass both.
- 23:09Write the plan in three sections, the
- 23:10state which is, you know, the input
- 23:11information, the questions with their
- 23:13criteria, and the routing with a
- 23:15threshold for every rule. So, this is
- 23:16the confidence level that passes that
- 23:18given rule. Keep that in one file. Show
- 23:20me the plan before you run anything. And
- 23:21you could just ask to see the scripts
- 23:22that it's going to send to Type Safe or
- 23:24Jev, but this way we can copy this,
- 23:26paste it into our Claude code instance
- 23:28with Type Safe, and actually start
- 23:29running that.
- 23:31And what it's going to do is effectively
- 23:32come back with a plan, right? So, at
- 23:34this point we're less concerned with how
- 23:36quick it's going to run because what
- 23:37we're actually just trying to do is come
- 23:38up with a good plan with a good set of
- 23:40questions so that we can run it
- 23:42effectively using Jev. Jev is only going
- 23:44to be really powerful for these bulk
- 23:45workflows and useful if you can ask good
- 23:47questions and Claude or an LLM is able
- 23:49to break down our requirements into
- 23:51those good questions. So, we've now got
- 23:53Claude's plan back in the questions.py
- 23:56file. And the first thing that we can
- 23:58see in Claude's plan is the state or
- 24:00what each email looks like when it
- 24:01reaches Jev. So, it's used the skill to
- 24:03determine what this state should look
- 24:05like. Now, you can see that we've got
- 24:06ID, received at, plan, subject, body,
- 24:08all these different fields. So, what it
- 24:10said is actually we need one object per
- 24:12email rather than a flat string where
- 24:15each part gets a descriptive name so the
- 24:16relationship stay clear. So, it's going
- 24:18to include customer facts like the plan
- 24:20or the customer they've or when they've
- 24:22been a customer since because the
- 24:24founding customer on the top plan is a
- 24:25completely different scenario from a
- 24:27day-old trial and Jev will want to treat
- 24:29that differently. So, it's basically
- 24:30mapped out the CSV columns here
- 24:33and given it some scripts. So, it's
- 24:34going to turn one CSV row into a state
- 24:36or input for a triage request. So, every
- 24:38single row is going to have information
- 24:41about the email which is going to be
- 24:42passed into Jev and information about
- 24:43the customer. So, it's going to be
- 24:44broken down into these specific
- 24:46sections. And that's because the skill
- 24:47told it to so that a question can point
- 24:50at a field by name and it's left
- 24:52everything that's irrelevant out of that
- 24:54like the previous thread history because
- 24:55the more irrelevant text it could
- 24:57potentially bring into the the
- 24:58decision-making process. And that brings
- 25:00us to kind of the limitation or the hard
- 25:02limit of 64,000 tokens per request that
- 25:05you send to Jev, but you should never be
- 25:07near that. It's not designed like an LLM
- 25:09where you have a million tokens in the
- 25:11input. It's it's very different. These
- 25:12structured requests are, as they sound,
- 25:14very structured, to the point, and
- 25:16minimal. They ask very defined sets of
- 25:17questions. We've also got a state for
- 25:20the second pass, which is actually based
- 25:22on the subject and body of the email
- 25:24that's been drafted. And we've also got
- 25:25a second state for that second pass that
- 25:28we're going to do when Claude drafts a
- 25:29reply. So, it's going to contain
- 25:30information about the email and the
- 25:32actual draft reply to see if we've
- 25:33answered the question, which was the
- 25:35second pass that we were going to do.
- 25:37The second thing that it's broken down
- 25:38here are the questions. So, we've got
- 25:40five questions per email in one single
- 25:43request. So, every single email in that
- 25:46CSV is going to get all five questions
- 25:48answered in one single request, and
- 25:50that's fine because every single
- 25:51question we add to that, we could have
- 25:5310, 15 questions, a basically free. So,
- 25:56we can continue to add these defined
- 25:58questions for free, and that's why we
- 25:59send them all at once so we can have
- 26:00this parallel processing of all of the
- 26:02different criteria. And in each
- 26:03response, we're going to get a score
- 26:05level
- 26:06and a confidence level back from Jev.
- 26:09And you can see it's built out these
- 26:10different triage questions. So, the
- 26:11first one we've got is a choice
- 26:12question. It says, "What is the support
- 26:14email primarily about?" If it's about
- 26:15billing, then the criteria is about
- 26:17charges, invoices, payments,
- 26:19subscription cost, but it's not for
- 26:20things like login or access problems.
- 26:22So, we're being very specific what it is
- 26:23and what it isn't, and it's given some
- 26:24examples in there. Then we've got
- 26:26technical, feature request, account, and
- 26:28none.
- 26:29And like we said, in every request, we
- 26:30want to give it an out. We want to give
- 26:31it a none so that it can actually choose
- 26:33that rather than trying to just
- 26:34pigeonhole it into one of these
- 26:35categories. And then we've broken it
- 26:37down for things like asking for money
- 26:38back. And again, we've got the criteria
- 26:40here for a null. If it's true, the email
- 26:42asks for money to be returned or
- 26:43credited. If it's false, the email makes
- 26:45no claim on money already paid. And it
- 26:47says, "Asking to cancel without
- 26:48mentioning a refund is false." So,
- 26:49they're not going to get that money back
- 26:50for that. We've broken down how badly
- 26:52broken and that is a score. So, the
- 26:54score gives the different criteria from
- 26:56effectively one to four. Nothing is
- 26:58broken, it's a cosmetic damage, it's
- 27:00annoying, and they cannot use the
- 27:01product. Now, what's really important
- 27:03here is we're really specific with the
- 27:04criteria. So, what does annoying
- 27:06actually mean? It means a feature is
- 27:07degraded or fails sometimes and there is
- 27:10a workaround. So, because we specified
- 27:11that, Jeff can be more sure in its
- 27:14determination of whether it's annoying
- 27:16or not annoying. And it's important to
- 27:17remember that every single email gets
- 27:20put through the same criteria. So, for
- 27:21example, a billing email will still go
- 27:23through and get asked these breakage
- 27:24severity questions. So, how badly is the
- 27:27product broken for this customer,
- 27:28judging by what the email describes? It
- 27:30will basically come back and say, "It's
- 27:32not at all." and therefore it will get
- 27:33ignored. But by sending all the
- 27:35questions at once, we can speed up,
- 27:36they're all parallel processed, we can
- 27:38basically just understand that it's
- 27:39nothing to do with breaking and
- 27:41therefore it's zero. And the actions are
- 27:43not taken off the back of that score
- 27:45then for that email. And then for anger,
- 27:47how angry is the customer, we've got the
- 27:48score. So, how angry does this customer
- 27:50sound? We've got the score from calm
- 27:51annoyed to furious. Then we've also or
- 27:53it Claude has also broken out how much
- 27:55judgment it needs. How much human
- 27:56judgment does this answer need? Is it a
- 27:58standard case? Is it a judgment or is it
- 28:00unusual? And that is a choice there. So,
- 28:02it's an option to choose any of those
- 28:03three. And the second part, we've got
- 28:04the verification questions around does
- 28:06it answer the question? Does it promise
- 28:08a refund or discount? And Claude is
- 28:09going to basically use the type safe
- 28:11skill to turn all of this information
- 28:12into a request that then gets sent to
- 28:14Jeff in the JSON structure that we saw
- 28:16earlier. But also inside here, inside
- 28:18the plan, we've got the routing rules.
- 28:19So, is it going to get sent to a person,
- 28:21engineering team? Is it going to be put
- 28:24into a
- 28:25pile for Claude to actually go and
- 28:26draft? It's got the different confidence
- 28:28levels that we're measuring this against
- 28:30and you can come in and change these.
- 28:31And it defines those confidence levels.
- 28:32So, if it's below this category
- 28:34confidence on rule number two, then it's
- 28:36not going to be trusted as a result and
- 28:38actually it's going to be routed to a
- 28:39person. And then we've actually got down
- 28:41here all the different routings in terms
- 28:43of actual scripts and Claude has gone
- 28:45ahead and written those scripts based on
- 28:46the type safe skill. You can see, like
- 28:48we said, there's no LLM determination
- 28:50here. It's purely a script. It will
- 28:52literally send all of the results from
- 28:53Jeb through these routes to actually put
- 28:55them into the right piles. And these are
- 28:57all if statements that are verifiable
- 28:59against the numbers that Jeb has
- 29:01returned as the output. So, you've seen
- 29:02now how to write this using Claude, and
- 29:04that's going to be a lot quicker than
- 29:05writing it yourself. But, the harder bit
- 29:07actually is knowing which questions to
- 29:09ask in the first place about your
- 29:10process. And this is the bit that I
- 29:12couldn't find online. Nobody has written
- 29:14up. So, I decided to make my own
- 29:16checklist that you can grab for free in
- 29:18the description below that you can go
- 29:19through to try and work out what
- 29:20questions you need to ask of your
- 29:22process or how to come up with the
- 29:23requirements that you can input as that
- 29:25initial prompt. So, this isn't even
- 29:26available in this skill that they
- 29:28provide for you. That's a very specific
- 29:29set of criteria of how to structure the
- 29:31requests to Jeb. But, here's the
- 29:33checklist that I've used for the
- 29:35different five question areas. And I've
- 29:37kind of pulled this together from the
- 29:38docs that I've read and the videos I've
- 29:40seen around the use cases of Jeb here.
- 29:42So, always think about it from what the
- 29:44software is going to do next, not from
- 29:46the data point of view. So, every
- 29:48question that you ask Jeb exists because
- 29:50an action or it needs to trigger an
- 29:52action. An action depends on it. So,
- 29:54you're going to list the actions first.
- 29:55That's number one. So, ours, if you
- 29:57remember, were Claude replies, uh going
- 29:59to put it into an engineering queue,
- 30:00going to put it into a feature log, or
- 30:02send it to a person, route it to a
- 30:03person. And then for each action, you're
- 30:05going to write the trigger as a
- 30:06sentence. And that sentence is going to
- 30:07form your question effectively. Let's
- 30:09use the example of send it to a person
- 30:12when it's about money. And that sentence
- 30:13is the question, and it also tells you
- 30:14the action, which tells you the type.
- 30:16So, if it's going to act or not act,
- 30:18it's a null or yes/no. If it's going to
- 30:20choose a different destination, then
- 30:22it's a choice. It's like a routing
- 30:23problem. Or if it's sorting, then it's a
- 30:25score. Thirdly, we're going to write
- 30:26down what a person would look at before
- 30:28making that call. I.e., what is the
- 30:30input? What's the state? And in this
- 30:31case, it was an individual email or a
- 30:33list of emails. And then number four,
- 30:35we're going to add what else could be
- 30:36true that would change the routing. So,
- 30:38this These are your edge cases, even if
- 30:40they're super rare. And that's where bug
- 30:42severity came from. We're going to
- 30:43re-route depending on bug severity and
- 30:45we're going to actually then score that.
- 30:46And then number five is deciding what a
- 30:48wrong answer is going to cost you so
- 30:50that you can set those confidence levels
- 30:52or those tolerances. So that's going to
- 30:53set the threshold for each action. And
- 30:55you saw that we had all of our different
- 30:56confidence thresholds. Now I've gone
- 30:58ahead and run this on all 50 emails in
- 31:00that CSV. It took 4.2 seconds for all 50
- 31:02to be run using eight concurrent workers
- 31:04so it's done that in parallel. It would
- 31:06have taken 31 seconds sequentially which
- 31:08is how you probably do it with an LLM.
- 31:09It would have taken 31 seconds
- 31:11sequentially so it's able to actually do
- 31:12those all at once. And the cost was
- 31:150.0026 for all 50 which is roughly
- 31:17equivalent to 19,000 emails equaling a
- 31:20dollar. So if we run this every morning
- 31:21for 50 emails it's going to cost us
- 31:23about a dollar a year. So extremely low.
- 31:25It's put it into this markdown file for
- 31:27us to easily digest the results and it's
- 31:29told us it's sorted by priority. So it's
- 31:31basically said 70% anger, 30% severity
- 31:34in terms of the weighting it's given it
- 31:36on priority. You can see that 19 of them
- 31:38rooted to a person based on my anger and
- 31:40severity. And it gives us, you know, the
- 31:41subject, why it's been categorized as
- 31:44that. So this for example is somebody
- 31:45asking for their money back. On a scale
- 31:48of naught to three I think it was they
- 31:49are super angry and it's clearly
- 31:51something severe or it's been deemed
- 31:53severe by Jev. And therefore our
- 31:55customer support person or customer
- 31:56support rep has a prioritized list of
- 31:58cases to go through every single morning
- 32:00and it took less than 10 seconds to work
- 32:02that out. We've then got a bunch of
- 32:04requests in the engineering queue that
- 32:06have been rooted there, some feature
- 32:07requests and 19 to actually just be
- 32:10replied to by Claude. Stuff that is no
- 32:11longer a task for our customer service
- 32:13rep. So now you've seen how you compare
- 32:16Jev with Claude, here are the rules you
- 32:18need to follow to get the most out of
- 32:20it. These are the patterns taken
- 32:22directly from the docs. So number one is
- 32:24actually kind of counterintuitive but
- 32:26super interesting insight which is ask
- 32:27everything at once. We're going to ask
- 32:29all five questions like we did earlier
- 32:31in one request. So the problem this is
- 32:33going to solve is waiting for it and
- 32:34this is why it's so incredibly quick. So
- 32:36with a chat model you're going to ask
- 32:37one thing, wait, then decide what to ask
- 32:39next. But, with Javelin, every question
- 32:41in a request runs in parallel, like we
- 32:43saw, and you only pay to read the text
- 32:45once. So, you ask everything up front,
- 32:47including questions that might not
- 32:48apply, like the bug severity for our
- 32:50billing scenario earlier, and then it
- 32:51ignores what you don't need. And this is
- 32:53called speculative fan out. So, for
- 32:55example, if it comes back as a billing
- 32:56query, the bug answers just get
- 32:58completely ignored in the processing.
- 33:00And if it was a bug, you already have
- 33:01the severity, and you don't have to make
- 33:03another call to understand the severity.
- 33:05There's one request, multiple questions
- 33:06in that request, multiple types of
- 33:08request, null, choice, scored. Pattern
- 33:11two is gating decisions based on your
- 33:13confidence level for specific actions
- 33:16will help you build systems that are
- 33:17both reliable and safe. Now, I know that
- 33:19was quite wordy. An example that
- 33:21Typeface used directly in their docs is
- 33:23voice banking. So, let's say under 0.6
- 33:25confidence, so 60% confidence, nearly
- 33:2750/50, it's going to get redirected to a
- 33:29person. So, check my balance at 0.6 is
- 33:32fine because the worst-case scenario is
- 33:34somebody hears their balance if it goes
- 33:35wrong. But, we need to gate different
- 33:37actions differently. So, approve the
- 33:38transfer needs to be a lot more
- 33:40confident, say 0.85, 0.95, and below
- 33:43that it asks you to confirm if that is
- 33:45the action you're wanting to take first.
- 33:46And you can see this in the demo from
- 33:48the voice browser from the start. Scroll
- 33:49down just happens. It just scrolls down
- 33:51immediately. But, anything destructive,
- 33:53like closing a tab, is going to stop and
- 33:55ask you to confirm before it does so.
- 33:56And that's because it falls in below the
- 33:58confidence threshold that they've set.
- 34:00So, you have one confidence threshold
- 34:01per action set by what it costs you to
- 34:04actually be wrong on that action. Now,
- 34:05pattern three is basically scoring the
- 34:08individual parts by breaking it down
- 34:09into into individual questions and
- 34:11weighing them or adding them together.
- 34:13And this rule or pattern exists because
- 34:15you're encouraged to break the judgment
- 34:16of these different things, independent
- 34:18dimensions, into separate questions that
- 34:21we can score each one separately and
- 34:23then combine them with weights so that
- 34:25we can then control the routing in the
- 34:27code. And I'll give you an example to
- 34:29bring this to life, which is big, messy
- 34:31judgments. So, we could have a bunch of
- 34:33CVs, right? And we could ask, is this a
- 34:36good candidate? Score it 1 to 10. And
- 34:38you get one number from Jev that you
- 34:41can't question. So, it's hard to know
- 34:42what criteria is used to determine the
- 34:44outcome there. But what we might do
- 34:46instead is break that down into what
- 34:47good might look like. So, it might be
- 34:49for engineer, Python depth of knowledge,
- 34:52team leadership skills, system design,
- 34:55or how fast they pick up new things. So,
- 34:57for a senior engineer, you could weight
- 34:59the Python skills and the design at 40%
- 35:01each as the threshold. But for a manager
- 35:03position, maybe leadership gets 40% as
- 35:06the threshold. Now, pattern four then in
- 35:09the final pattern is routing it to the
- 35:10best handler for that job. Or this is
- 35:12called intent routing. So, we're going
- 35:14to classify incoming requests and route
- 35:16each to the optimal handler, whether
- 35:18that's deterministic logic inside a
- 35:20script like we saw, a specialist LLM
- 35:22like Claude, or a human. So, TypeSafe
- 35:25can sit in front of all these as a fast,
- 35:28cheap classifier that determines which
- 35:30handler to invoke, whether to send it to
- 35:31our human customer support rep or not.
- 35:33So, like where's my order is going to go
- 35:35to a database look up. That's not going
- 35:37to use AI. It's not going to require a
- 35:38human. But a product question is going
- 35:40to go to Claude who has access to the
- 35:41product docs. And then a complaint is
- 35:43going to get a second question of how
- 35:45complex is this complaint. And then the
- 35:46messy ones are going to go completely to
- 35:48a person from the get-go. And then
- 35:50anything with low confidence is not
- 35:52going to hit the threshold and it's
- 35:52going to go to a person anyway. And when
- 35:54you bring all of those four patterns
- 35:55together, you get the smart home demo
- 35:58that TypeSafe have directly on their
- 36:00docs that uses all of this at once. So,
- 36:02this is about controlling your lights
- 36:04and your gadgets in your house using
- 36:06voice effectively or using typing
- 36:07commands or using an app. So, you type
- 36:09in turn off all the lights in the house.
- 36:10One request is going to ask which kind
- 36:12of request is it, which rooms, which
- 36:14device, and what action needs to take
- 36:16place. And then if you type two commands
- 36:18in one sentence, Jev is going to spot
- 36:20that it's a compound request and
- 36:21actually hand it to an LLM to split
- 36:23that. It's then going to judge the two
- 36:24halves there. So, it understands that it
- 36:25needs to actually split the request into
- 36:27multiple questions there. And then if
- 36:28you ask just a general question that's
- 36:29unrelated, it knows to pass it to an LLM
- 36:31to answer that. And that is effectively
- 36:33pattern four. And the whole point in
- 36:34that is that they put Jev
- 36:36next to the LLM, and you basically Jev
- 36:39works so quick on these deterministic
- 36:41actions where you've got questions,
- 36:42threshold, confidence, etc. That you
- 36:44don't even notice he's there. It can
- 36:46make judgment calls on things so quickly
- 36:48that decide the next most probable step
- 36:50to take depending on score and
- 36:52confidence against your criteria. So, if
- 36:53you can't tell, I am super excited about
- 36:55this because when you pair it up with
- 36:56Claw code or GPT-Astra, you've got one
- 36:59hell of a combination. Jev can do a lot
- 37:01of those deterministic or more
- 37:03deterministic categorizations in rapid
- 37:05time and for record low cost. Whilst
- 37:07Claw can do the chat back and forth, the
- 37:09reasoning and the judgment where extra
- 37:10thinking or looser requirements, for
- 37:12example, are required.
- 37:14Now, if you want to see a video on
- 37:15applying this combination to a domain
- 37:17like GEO or browser use, then drop a
- 37:20comment below and see you in the next
- 37:21video.
About this transcript
This page contains the full transcript of Jev + Claude = INSANE Results (Every Concept Explained) by Simon Scrapes, generated from the public captions YouTube serves with the video. The transcript has 8,870 words across 1,256 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.
What you can do with it
Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.
Free YouTube transcript tool
YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.