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

September 30, 2026

AI Summary

5 min read

John Lindquist has spent pennies—literally seventy-three cents—running dozens of experiments with Jev, the decision model from TypeSafe AI that outputs structured scores and classifications instead of free text. On How I AI, he walked Claire Vo through eight real use cases that show what becomes possible when a model is both nearly free and ten times faster than a typical LLM. The conversation is less about hype and more about a practical shift: Jev turns problems that felt too expensive or slow into problems you can actually solve.

Why Jev changes the calculus

Jev is not a generative model. You feed it unstructured text, and it returns structured data—decisions, scores, yes/no probabilities, or a choice from a limited set of options. That constraint is the source of its power. As Lindquist puts it, “LLMs are unstructured to unstructured. This one is unstructured to structured.” The result is a model that costs about four cents per million input tokens and runs fast enough to feel like an if-else statement. Vo describes it as “the smartest function”—a function with real intelligence built in, but still a function.

Continue reading the full summary in the app — free to try.

Read Full Summary →

Free • No credit card required

Listen to Audio Summary Open in App

Never miss an episode of How I AI

Get every new episode summarized in your inbox — free, ~5 minutes to read.

No spam. Unsubscribe anytime.

What you'll learn

1 (00:00) **Why Jev is exciting: fast, free, and unlocks new possibilities** - John Lindquist explains that Jev is essentially instant and costs pennies, opening up data exploration that was previously too expensive or slow.
2 (04:37) **What Jev is and how it differs from traditional LLMs** - Jev outputs structured decisions and scores rather than unstructured text, making it ideal for routing and classification.
3 (06:18) **Demo 1: Real-time voice-controlled to-do app** - John shows a to-do list that responds to natural language dictation, adding, completing, and prioritizing tasks in real time.
4 (08:56) **Mental model: Jev as the new if-else statement** - John explains how to think about building with Jev by identifying all the conditional decision points in a program.
5 (11:09) **Demo 2: Natural language to function routing** - John demonstrates mapping plain English to function names, the core of Jev’s classification capability.
6 (11:49) **Demo 3: Data deduplication and merging** - Jev can rapidly scan large datasets and merge duplicate records with configurable confidence thresholds.
7 (15:08) **Demo 4: Multi-step routing and tool selection** - Jev can route user intents through multiple layers of classification to select the right tool and action.

+ Full timestamped outline available in the app

Guests on this episode

Claire Vo

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:

Why Jev is a decision engine, not a chatbot, and what that distinction actually changes about how you build
How John built a real-time voice to-do app that classifies and executes commands with no visible pause
The data deduplication pattern that merges messy records in milliseconds using confidence scores
Why Jev works best as a router, and how a single text input can navigate users deep into an app
What a chess match between Jev and a low-reasoning LLM reveals about speed, cost, and when to use which
The multi-step classification pattern John reaches for when one Jev pass isn’t enough
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<