Skip to content

Jev: 8 real use cases for the fastest, cheapest model I’ve ever used | John Lindquist

How I AI

46m
Transcript

Original podcast

Summary

Written by a model from the transcript; not yet reviewed.

This episode of How I AI features product leader Claire Vowell and repeat guest John Lindquist discussing Jev, a fast, practically free decision model from TypeSafe AI. Unlike traditional LLMs that output unstructured text, Jev outputs probabilities, scores, and decisions, making it exceptionally fast and cheap for tasks like data deduplication, live voice routing, and game mechanics. Throughout the conversation, the guest walks through numerous demos, highlighting how a sub-second decision model unlocks use cases that were previously too expensive or slow to pursue. They also explore architectural patterns like multi-pass classification and discuss how treating agents and decision models as fast routers fundamentally changes software development.

  • When building with Jev, consider chaining multiple classification layers or adjusting confidence score parameters if your initial single-pass results are not accurate enough. 7:07
  • Instead of relying on large generative models for tasks with constrained inputs or limited choices, use Jev as a fast, cheap decision router. 0:13
  • Large unstructured datasets like gigabytes of JSON can be processed and organized efficiently and cheaply using a decision model. 3:33
  • For complex workflows that require multiple steps, you can build abstractions where Jev acts as a router selecting the appropriate smaller tools in sequence. 16:16

Chapters

  1. 0:00
    Episode Intro and Jev Overview

    Claire introduces the episode, welcomes John, and explains the focus on Jev, a fast, free decision model.

  2. 0:56
    Why Jev Excites the Host

    Claire shares her enthusiasm for Jev’s speed, cost, and discovery capabilities, setting the stage for demos.

  3. 4:25
    Routing and Navigation Use Cases

    Claire and John discuss how Jev can act as a router for multi‑step workflows, search, and browser interactions.

  4. 5:49
    Gaming and Real‑Time Decision Making

    John explains Jev’s application in chess and other games, highlighting speed advantages over LLMs.

  5. 6:21
    Live Voice Demo – To-Do List Management

    John demonstrates Jev’s real‑time voice processing by dictating to‑do list actions and showing live function calls.

  6. 7:05
    Practical Product Examples – Presentation Coach

    John presents a live presentation‑coach demo that tracks bullet points and keeps speakers on track.

  7. 11:09
    Data Deduplication and Merging Demo

    John showcases Jev’s ability to merge duplicate records across large datasets with confidence scoring.

  8. 36:21
    Cost, Performance, and Limitations

    Claire and John discuss Jev’s pricing, latency, and scenarios where additional LLM layers may be needed.

  9. 39:55
    Lightning Round and Future Directions

    The hosts recap key points, hint at upcoming projects, and tease future episodes exploring Jev’s potential.

Highlights

  • 5:35

    Unstructured to Structured Outputinsight

    The guest explains that while traditional LLMs map unstructured text to unstructured text, Jev maps unstructured input sentences into structured data, decisions, and probabilities.

  • 12:01

    Data Reconciliation at Scalestory

    The guest demonstrates how Jev can perform pairwise comparisons on messy datasets, such as merging duplicate business contact records in milliseconds.

  • 20:08

    Playing Blitz Chessdata

    The guest showcases a demo where Jev plays chess against a low-reasoning LLM, evaluating multi-step moves and making decisions ten times faster.

  • 24:29

    Demystifying Browser Useinsight

    The host argues that complex browser navigation or game actions can be simplified into a dozen clickable decisions, which Jev handles almost instantly.

  • 29:03

    Simulating Multi-Agent Navigationstory

    The guest shows a simulation of multiple agents navigating a warehouse and avoiding collisions by checking constraints at each step.

  • 33:52

    Managing Presentation Bullet Pointsstrategy

    The guest demonstrates a presentation coach demo that listens to real-time speech and checks off covered bullet points as you talk.

  • 38:12

    Handling Classification Shortcomingsstrategy

    The guest shares a strategy for overcoming classification limitations by layering multiple classification passes rather than relying on a single pass.

Quotes

  • “Fast and free are both amazing.”
    Unnamed speaker · 2:31
  • “I think of all the time I've spent on this and the hundreds of demos I made, I think I've spent 73 cents on it.”
    Unnamed speaker · 2:45
  • “And I love the one quote someone said, 'I think I'm going to pass this inheritance of Jev on to my children once I die.'”
    Unnamed speaker · 2:53
  • “Jev is a router, is maybe like, what's helpful. A very, very fast router.”
    Unnamed speaker · 16:59

About this episode

John Lindquist created egghead.io, a developer education platform used by hundreds of thousands of working engineers. These days he’s building mega.dev, a hands-on program specifically for developers who want to do real work with AI agents, not just prototype them. What you’ll learn: Why Jev is a decision engine, not a chatbot, and what that distinction actually changes about how you buildHow John built a real-time voice to-do app that classifies and executes commands with no visible pauseThe data deduplication pattern that merges messy records in milliseconds using confidence scoresWhy Jev works best as a router, and how a single text input can navigate users deep into an appWhat a chess match between Jev and a low-reasoning LLM reveals about speed, cost, and when to use whichThe multi-step classification pattern John reaches for when one Jev pass isn’t enoughWhere Jev falls short, and when you should still reach for a full generative model— Brought to you by: Vanta https://www.vanta.com/howiai—Automate compliance and simplify security — In this episode, we cover: (00:00) John Lindquist returns for Jev week (04:32) What Jev actually outputs (06:15) Demo: real-time voice to-do app (08:17) How sequential Jev calls chain together (10:38) Demo: plain English to function name (grocery cart) (11:50) Demo: data deduplication and record merging (13:45) Confidence scores and multi-model validation (15:06) Demo: Jev as a multi-level app router (18:23) Architecting around Jev (19:35) Demo: Jev vs. traditional LLM at chess (speed and cost benchmarks) (24:29) DOM interactions as a decision set, not an infinite canvas (28:21) Demo: Wikipedia “path to philosophy” route mapper (30:28) Demo: multi-agent coordination and collision avoidance (33:36) Demo: real-time presentation coach (36:56) Quick recap (39:54) Lightning round and final thoughts — Tools referenced: • Jev (TypeSafe AI decision model): https://typesafe.ai/blog/introducing-system-one-models-and-jev • Vercel AI Gateway: https://vercel.com/docs/ai-gateway • OpenRouter: https://openrouter.ai https://openrouter.ai/ • Opus 5.5 (mentioned in context of iterative demo building): https://www.anthropic.com/claude-opus-5-5 — Where to find John Lindquist: LinkedIn: linkedin.com/in/john-lindquist-84230766 http://linkedin.com/in/john-lindquist-84230766 X: https://x.com/johnlindquist Mega.dev: https://mega.dev/ Egghead.io: https://egghead.io/ — Where to find Claire Vo: ChatPRD: https://www.chatprd.ai/ Website: https://clairevo.com/ LinkedIn: https://www.linkedin.com/in/clairevo/ X: https://x.com/clairevo — Production and marketing by https://penname.co/. For inquiries about sponsoring the podcast, email [email protected].

Transcript

0:00
46:06

8,188 words · 2 speakers

Topics

  • Jev
  • Chess
  • Mega Dev
  • Claude
  • Wikipedia
  • Tetris
  • TypeSafe AI
  • OpenRouter
  • Cursor
  • Google Contacts

Page updated · transcript and summary are machine-generated