How I AI

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

· Summarized

Share this episode
Anyone with this link can open it.
Share Link
Start at 0:00

Key takeaways

  • Jev is a decision engine that outputs structured decisions, scores, and probabilities instead of freeform text, making it much faster and cheaper for production use.
  • The model is highly effective for real-time applications like voice command classification, data deduplication, app routing, and multi-agent coordination because of its speed and ability to chain decisions.
  • Developers can architect around Jev by chaining multiple calls and using confidence scores to improve accuracy, almost like building multi-layer classification systems.
  • Jev outperforms traditional LLMs in specific scenarios like playing chess or web navigation when speed and cost are critical, with benchmarks showing 10x faster and 4x cheaper performance in some cases.
  • While Jev is highly capable in decision tasks, it may require multiple passes or additional layers for complex or nuanced classification, and prompt engineering can enhance its accuracy.
  • The episode showcases a broad range of practical, real-world use cases—from game strategies to presentation coaching—highlighting Jev’s flexibility in various domains.
  • Speed and cost efficiency unlock new creative and productivity possibilities that were previously impractical with traditional AI models, enabling real-time interactions and decision-making.
  • Future developments are expected to improve Jev further, and AI decision models are poised to replace slower, more expensive models in many applications.

Summary

Introduction to Jev and the Podcast Episode's Focus

The episode kicks off with Claire Vell introducing her guest, John Lindquist, a repeat guest known from a previous popular episode. They are celebrating 'Jev Week,' a period focused on a new AI model called Jev. Claire emphasizes the excitement around this model, which is not like traditional large language models (LLMs). Instead, Jev is a decision engine that outputs decisions, scores, and probabilities rather than just text, making it significantly faster and cheaper in a production context. They highlight the vast number of demos John has prepared, illustrating Jev’s capabilities across various practical use cases.

Deep Dive into Jev's Technical Capabilities and Use Cases

Claire and John explore Jev's core features, emphasizing its decision-making architecture over open-ended generative output. They discuss how Jev allows for rapid, real-time interactions, such as dictation apps that classify and execute commands instantly while listening. John demonstrates a to-do list management system where voice commands are analyzed and matched with specific tasks and functions through multiple analysis layers, including confidence scoring. They cover how chaining multiple Jev calls can build complex workflows, akin to traditional programming conditionals, but with speed and simplicity. John also explains how Jev can classify unstructured data into structured formats, supporting use cases like data deduplication, record merging, and navigating complex apps through natural language.

Architectural Patterns and Practical Examples for Jev

The conversation shifts to how developers can architect around Jev, using it as a router and decision-making layer. John illustrates with examples like guiding users through apps or routing commands to the appropriate back-end functions. They discuss building multi-layer classification systems by running sequential Jev passes, which improves accuracy. Several demos are mentioned: a Wikipedia path mapper connecting topics to philosophy, multi-agent coordination to avoid collisions, and voice coaching tools that monitor speech for completeness and timing in real time. The episode emphasizes Jev’s role in making complex interactions more efficient—such as web navigation, game moves, or even image analysis—by reducing the need for expensive, slow generative models.

Performance Benchmarks and Use Cases in Gaming and Web Interaction

John compares Jev's performance in scenarios like chess, where it can reason through moves at high speed, to traditional LLMs, showing Jev is 10 times faster and four times cheaper in these tests. They highlight how speed unlocks real-time capabilities previously thought impossible. Examples include navigating websites by identifying actionable buttons, playing fast-paced games like Tetris, and simulating decision trees for user interface interactions. Discussions occur around how Jev handles constrained inputs efficiently, transforming seemingly infinite possibilities into manageable decision sets. Claire adds insights about image analysis and how Jev can complement LLMs by providing structured decision outputs, especially in data-heavy tasks.

Limitations and Optimization Strategies for Jev Usage

The hosts acknowledge that Jev isn't perfect and discuss situations where multiple classification passes or additional layers are necessary for accuracy. John mentions testing different prompt formulations and the importance of thresholds like confidence scores. They note that while Jev is very fast and cost-efficient, it may not replace all generative tasks but excels in decision and routing applications. Claire asks about practical setup, including managing how input streams are chunked and processed, and they advise iterating prompt design and thresholds for better precision. The episode concludes with a reminder that Jev's current state is early in its adoption, with improvements expected over time.

Final Highlights and Personal Reflections on AI and Hardware

In the closing segment, John and Claire reflect on how Jev unlocks possibilities once limited by cost and speed constraints. John shares personal anecdotes about managing local hardware setups—hard disks, disks space optimization, and remote Mac Minis—highlighting that real-world use often involves overcoming infrastructure challenges. They speculate on future trends, suggesting that AI decision models like Jev will increasingly replace traditional, slow, and costly AI solutions. The episode ends with a quick lightning round, where John shares interests beyond AI, including multimedia and game development, emphasizing the importance of fast, local processing. They joke about hardware issues and how AI might eventually be embedded directly into devices, reducing reliance on extensive infrastructure.

Sponsors

  • Vanta · Vanta works differently. Their agentic trust platform is built to scale with you, not slow you down. With over 1400 automated tests across 400-plus integrations, Vanta collects evidence and monitors your controls year-round, cutting your audit prep by 82%. Plus, you can access the Vanta agent everywhere you work, whether your team is in Vanta every day or living in tools like quad or cursor. Want proofs over 16,000 fast growing companies like Ramp, Writer, and Harvey? Save time and resources while scaling fast with Vanta.

Show notes

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:

  1. Why Jev is a decision engine, not a chatbot, and what that distinction actually changes about how you build
  2. How John built a real-time voice to-do app that classifies and executes commands with no visible pause
  3. The data deduplication pattern that merges messy records in milliseconds using confidence scores
  4. Why Jev works best as a router, and how a single text input can navigate users deep into an app
  5. What a chess match between Jev and a low-reasoning LLM reveals about speed, cost, and when to use which
  6. The multi-step classification pattern John reaches for when one Jev pass isn’t enough
  7. Where Jev falls short, and when you should still reach for a full generative model

—

Brought to you by:

Vanta—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

• 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

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 jordan@penname.co.

Follow this show on AudioBrevity and new episodes get summarized for you. Create a free account

Couldn't load the audio. A blocker may be stopping the show's tracking links. Open the file