Video summary

Why Developers Are Losing Their Minds Over AI That Can't Write

Main summary

Key takeaways

Technology

Technological concept: “Jev” as a multi-choice, fast AI classifier (can’t generate text)

  • Jev is described as an LLM-like model that “can only talk in multiple choice.”
  • It can read provided input, but cannot write freeform text back.
  • Instead, you supply all allowed answer options in advance, and Jev selects one (or provides scores/probabilities) among them.
  • The key architectural idea is a “glue between language and choice”: transform complicated natural-language inputs into structured, program-friendly decisions.

Product/framework positioning (Typesafe / “Jev” launch)

  • Typesafe shipped Jev on September 15 (year implied by context; later mentions reference “2026”).
  • Adoption claim: within 24 hours, Jev reportedly became the fastest adopted model in a specific “Verscell AI gateway” history, also claiming:
    • 2x+ more paid teams than prior models in the first 24 hours.
  • This is framed as either:
    • strong developer enthusiasm, or
    • the point of Jev being designed for refusal to “write” (i.e., structured outputs only).

Why this matters vs LLMs

The video argues that many real problems are “complicated in, simple out” (classify/select/score).

Historically:

  • Deterministic rules (if/then) work for clear patterns, but fail for ambiguous text requiring judgment.
  • LLMs can do judgment, but are relatively expensive for high-volume decision tasks.
  • Custom ML classifiers exist, but are typically expensive to build/maintain:
    • data labeling
    • retraining
    • evaluation
    • and they don’t scale well across many micro-decisions.

Jev is pitched as a general-purpose classifier that is:

  • fast
  • cheap
  • trained for structured decision output, making it cheaper than using LLMs for classification.

“Semideterministic” / AI safety angle

The speaker calls it “semi-deterministic”:

  • you don’t author the exact decision logic as rules
  • but the output remains probabilistic judgment rather than fully deterministic logic

In agent workflows and AI safety, Jev can cheaply review proposed actions and output:

  • Yes / No
  • Proceed / Don’t proceed
  • Ask a human for safety escalations

This is presented as enabling more safety checks throughout an agent run, not only at the end.

Core technical properties claimed

  • General-purpose: can be applied to varied classification tasks without training a new specialized model each time.
  • Multi-question evaluation: can evaluate several classification questions at once.
  • Outputs can include:
    • chosen category
    • score
    • probabilities
    • structured decision results consumable by code

Real-world use cases & architectures (patterns)

The video outlines several integration patterns:

  1. Classifier in the “front” of a workflow (between messy input and action code)

    • Support tickets → Jev categorizes (e.g., billing, urgency, churn risk), routes to the right team, and may trigger drafting responses.
    • Email classification → detect marketing opportunity, decide whether to reply, estimate opportunity size; then an LLM can draft.

  2. Safety/approval gating for agents

    • Before dangerous development actions (e.g., deleting folders, force pushing), Jev recommends asking the user.

  3. Outer loop orchestration (“put classifiers into the outer loop of a harness”)

    • Jev selects the next step/tool:
      • whether to call an LLM
      • whether to use a reasoning/foundation model for hard exceptions
      • whether to call a human
    • Analogy: like choosing navigation actions in a browser UI with limited buttons/links; also described as live interface composition.

  4. “Intelligence everywhere” via structured columns/fields (spreadsheet-like pattern)

    • Add a header like “urgency” and classify row-by-row.
    • Extend with multiple columns for missing-info detection, team selection, and combinations with normal formulas.
    • An optional LLM can be used later for generation, while Jev performs the upfront classification.

Performance/cost claims and pricing

The speaker emphasizes Jev is “dirt cheap” and fast, enabling scale.

  • Pricing cited: ~$0.042 per 1M input tokens (and $0 output cost).
  • Cost comparison (as stated by the speaker):
    • At 1,000 input tokens/request
    • 10,000 calls ≈ $0.42

Other claims (from Typesafe launch evaluation):

  • Up to ~100x faster
  • Over ~100x cheaper vs LLMs (wording implies orders-of-magnitude claims)

Cited examples from users/teams (as described)

  • Developer pipeline for tax documents

    • Switching to Jev reportedly achieved 34x lower cost and 6x faster processing.

  • Personal sorting

    • Sorting 20,000 items (emails/Slack/transcripts) in ~7 minutes for $1.

  • Bioscience selection task

    • From 10,000 candidate immunology questions, Jev selects top 100 quickly/cheaply.
    • Framed as deciding what deserves human/LLM attention rather than replacing LLM reasoning.

Weak spots / caveat

  • Jev is described as not perfect—it still requires testing for each classification problem.
  • The video frames Jev as most useful when the task is:
    • complicated language input
    • mapped to few structured outcomes
  • Where it “falls over” is not deeply detailed in the transcript, but the guidance is explicit:
    • validate fit experimentally.

Guides/tutorial / how to try (action steps included)

A practical “getting started” approach:

  • Copy a TypeSafe setup prompt for agents from Typesafe’s website into an agent framework (e.g., “cloud code/codeex”).
  • Ask the agent to:
    • install the TypeSafe skill
    • integrate it
  • Create an account, generate an API key, and let an agent guide the connection.
  • Test prompt offered:
    • Use the TypeSafe skill to find places where LLM choosing among defined outcomes is suboptimal, then build a Jev version and compare:
      • speed
      • cost
      • results
  • Mentions:
    • A linked full guide “in the description” (installation in ~5 minutes or less).
    • Recipe cards for each architectural pattern.

Strategic takeaway: “Jevens paradox” / cheaper classification unlocks more usage

Main message: when classification becomes much cheaper, the set of questions worth asking expands.

“Jevens paradox” framing:

  • References William Stanley Jevons (efficiency can increase overall consumption of a resource).
  • Applied here: cheaper intelligence makes it feasible to do many more judgments:
    • more per interaction/day/section
    • more frequent safety checks
    • more places where software elements can be intelligent

Main speakers / sources

  • Primary speaker: The model is referred to via “Jeb”/“Jev”; the speaker is Nate (Nate’s) / Nate something (referenced as “Nate why are you buying that?” and later “Sam Alvin said…”).
  • Referenced person(s):
    • Sam Alvin (quoted)
    • Developers mentioned (names include Nakshhatra Sakena, Zack Gone, Durya Unutz, James Ward, Nate Dobit—spelling uncertain in subtitles)
  • Product source: TypeSafe (the company that shipped Jev)

Original video