> ## Content Index
> Fetch the complete content index at: https://nnutshell.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Coding agents write faster, not better software; Jev adds intelligence
- URL: https://nnutshell.com/coding-agents-write-faster-not-better-software-jev-adds-intelligence/
- Published: 2026-10-23T18:14:59.000Z
- Updated: 2026-10-23T18:14:59.000Z
- Description: Diogo, founder of Type Safe who has worked at Google Brain and OpenAI, gets into Jev as a primitive inside code, reliability as the real goal, and why SaaS wins.
- Author: Admin
- Tags: Diogo, Type Safe, OpenAI, Foundation Models, Developer Tools, Enterprise SaaS, Agentic AI, #rec-2026-09-28, #Import 2026-10-25 09:54

*Recorded 28 September 2026 · 42 min*

Coding agents write the same code a human would have written a decade ago, so software itself is not getting better. That is Diogo's diagnosis. Jev, the model from Type Safe, is his answer: not a faster engineer, but a primitive placed inside a program so that software can do things it could not before. Diogo says he is a computer scientist first and an AI researcher second, and his path ran through a Kaggle win, Jeremy Howard's startup, Google Brain and OpenAI.

Two hosts, one of them Martin, press him on what this means for agents, SaaS and automation. The tension running through the talk is that AI is smart enough to solve math and still cannot handle a drive-through. Diogo blames an industry that optimized for impressing human judges rather than for automating work. His fix is reliability, built nine by nine. He is open about where Jev is not ready, and says he refuses to over-promise and under-deliver.

1. **Tragic automation gap** — [▶ 1:45](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=105s&ref=nnutshell.com)  
Diogo's pitch for Jev starts as a complaint: "where the fuck is all the automation?" AI is unbelievably smart and yet useless at most other work. He loves chatbots and coding agents himself, but calls the gap "tragic", a diamond in the rough not polished for work. Type Safe makes AI for software, aiming to be powerful beyond humans in the loop and able to build real software. Developers he knows keep calling to say Jev is fast and great, which is what first told his team something was happening.
2. **Smart software, not smart engineers** — [▶ 3:25](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=205s&ref=nnutshell.com)  
He does not want to automate software engineering. He wants to expand what software itself can do, so things that should be automatable become automatable. Programming, in his words, is "hyper specifying valuable things and then infinitely replicating them", and he wants a larger vocabulary of intent to specify. He likes the description of Claude Code and Codex as just-in-time software, which makes software on the fly in natural language with the same expressive power. The hosts frame the alternative as a faster, maybe not-as-good engineer versus super-empowered ones writing more interesting things.
3. **Same code, ten years on** — [▶ 4:27](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=267s&ref=nnutshell.com)  
Claude Code, Codex and Cursor write what a human would have written. It may be better or worse, but it is "basically still code, just like code looked 10 years ago". Jev is a new primitive you put inside the code, whether a human or an agent writes it. A host compares it to a library: describe intent in natural language, hand it a state machine, and it chooses actions with confidence levels. Diogo finds it wild that AI is so cool while software is unchanged in 10 years, with the most we do being a chatbot in the side panel.
4. **Absolutely a classifier** — [▶ 6:54](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=414s&ref=nnutshell.com)  
Asked whether Jev is just a classifier, Diogo says yes, and that classifiers are sick because practical people designed them to be useful. His guess is that Jev beats a 2019 machine-learning engineering team, since few such teams could collect data sets and measure them well. On day one of onboarding he draws a Venn diagram of what AI is good at versus what is valuable in code, so Jev avoids outputting extrapolated floats. He sees a slider between language and code. His north star is intelligence per dollar, and millisecond speeds make it more like a database than a standard library for now.
5. **RLHF nearly fooled him** — [▶ 17:47](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=1067s&ref=nnutshell.com)  
In Q4 2021 the team tried to disprove that RLHF was cheating. His favorite query was why it is important to eat socks before meditating, which they confirmed was not on the Internet, and the models still gave plausible answers. He thought the released model had a decent chance of being AGI, and when it was not, his "whole world came crashing down". RLHF generalizes well, he says, while RLVR generalizes less. He did not think and does not think the field is on the path of recursive self-improvement, though he thinks OpenAI's definition of AGI, automating most economically valuable work, is extremely doable.
6. **Optimizing the judge** — [▶ 20:45](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=1245s&ref=nnutshell.com)  
Since RLHF the industry has bifurcated into giant over-promising and under-delivering. Humans judge the models, so they look good, but the field has optimized the judge rather than the automation. Diogo calls automation the canary in the coal mine: math is solved and GPQA was solved two years ago, yet a drive-through is still out of reach. OpenAI has tried to automate customer service since 2020\. He rejects diffusion as an excuse, since the financial incentive to automate is huge. Inside companies, he and the hosts agree, almost nothing works besides programming.
7. **Long-tail objection** — [▶ 21:57](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=1317s&ref=nnutshell.com)  
A host argues that the real world is heavy-tailed and the data for it is missing, so models stay on low-dimensional manifolds like math and code. Diogo does not entirely buy the data argument. He grants the long tail exists but says the canary test does not require automating it. Building reliable software is an investment, an ROI decision, in the spirit of the programmer's virtue of laziness. A host adds a support example: a company said it answered 95% of help desk calls, but they were all password resets, and by uniqueness it was around 50%.
8. **Reliability is the product** — [▶ 25:43](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=1543s&ref=nnutshell.com)  
Diogo says Jev has been "blood, sweat and tears" on reliability for years, which makes a benchmaxed copycat hard to build. Every nine of reliability is valuable, even if not for market cap. He splits it into uptime, determinism and robustness. He prefers robustness, meaning similar intelligence every time, because exact determinism only serves unit tests. It needs to be "smart every time" so a developer can program around it. His highest honor would be developers programming against Jev without example queries, trusting it enough to stay in flow.
9. **Syntax yes, architecture no** — [▶ 29:01](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=1741s&ref=nnutshell.com)  
In his experience coding agents are really good at syntax, bad at semantics and incredibly bad at architecture, which he calls the most human creative part of software. He still loves using them. Jev is almost certainly not in their training distribution, so they will not help much with it yet. Maybe models are 50th percentile at architecture, which is fine if you know nothing about it. A company can choose to accept 50th percentile architecture instead of 60th, so speed becomes the knob and Codex works overnight.
10. **Inverse SaaSpocalypse** — [▶ 30:02](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=1802s&ref=nnutshell.com)  
Coding agents triggered the SaaS apocalypse story, and then every SaaS company loved Jev. Diogo thinks that story has panned out poorly. Software may be cheap but is not easy to replicate, because much happens beneath the hood. SaaS provides the same value as before, and he expects it to be one of the biggest winners of AI, calling it an "inverse sasspocalypse". Those companies know which workflows to automate and have already spent capex reaching all their users. He will not forecast markets. He imagines multi-choice forms disappearing.
11. **Ten-line pull requests** — [▶ 33:55](https://www.youtube.com/watch?v=Ut3LOjKNJaE&t=2035s&ref=nnutshell.com)  
The average pull request at a large company is about 10 lines, according to a study Diogo saw at Google. Automating that is a minor optimization and adds no new capability to the software. A new primitive can. He does not claim Jev reaches state consistency or durability, but it will change log analysis, emails, UIs and talking to humans. Over time it may become a smart database, even for air traffic control, which he finds a little scary. His rule is to automate the easy work first, with many nines needed in the guts.

Software has not improved in a decade, and AI coding agents have not changed that. They write what a human would have written, maybe better, maybe worse, in the style of code from 10 years ago. The typing gets faster and the ceiling stays where it was. Diogo points to a study he saw at Google: the average pull request at a large company is about 10 lines. Automating those lines optimizes something minor. With less oversight, the output is arguably getting worse. A tool that merely replaces the engineer with a faster, possibly weaker one does not make software better.

The alternative is to expand what software can do. Jev is a primitive you place inside a program. Think of a library where you describe intent in natural language, hand it a state machine, and it chooses what to do with some confidence level, something programmers have not had before. It works the same whether a person or Claude Code writes the call. Diogo's framing is that programming is specifying valuable things and replicating them endlessly, and Jev widens what can be specified. That is why he says he wants smart software, not an automated software engineer. The examples he reaches for are modest and concrete. Multi-choice forms could disappear. Someone built a voice interface that decides, moment by moment, whether you are issuing a command or dictating text.

The design is deliberately unglamorous. Asked whether Jev is just a classifier, he says it absolutely is, and that classifiers are "sick" because they were built to be useful. His guess is that Jev already beats a 2019 machine-learning team, since few companies could build one that good. On day one of onboarding he draws a Venn diagram of what AI does well against what is valuable in code, which is why Jev does not output extrapolated floats. The north star is intelligence per dollar, and millisecond latencies mean it behaves more like a database than a standard library for now.

There is a reason this did not exist already. Earlier attempts to embed AI in software failed because software does not take natural language. Developers stuck the JSON schema in the prompt and the model ignored it. So they gave the output to a human, which is the chatbot, or to another model in a loop, which is the agent. Diogo treats that as a kind of grief cycle: try, fail, accept, hand it off. Jev is meant to be the first thing that maps a model onto a state machine productively.

The larger diagnosis is about what the industry chose to optimize. Since RLHF, human raters have judged the models, so they look good because the raters are the judge. The field optimized the judge instead of the automation. Diogo's canary is plain: math is solved, and GPQA was solved two years ago, yet nobody can automate a drive-through. OpenAI has been trying to automate customer service since 2020\. He rejects diffusion as an excuse because the financial incentive is enormous. He has a personal stake in the story. In late 2021 he thought the RLHF model had a decent chance of being AGI, and when it was not, his world "came crashing down". He still does not think the field is on the path to recursive self-improvement. He thinks OpenAI's definition of AGI, automating most economically valuable work, is extremely doable, because the intelligence for rote work has been in the models for quite a while.

If the missing piece is not intelligence, it is reliability, and he is specific about what that means. Uptime is one part. Determinism is another, but he does not want exact determinism, which he says only serves unit tests. What he wants is robustness: it needs to be "smart every time", so a developer can program around its behavior. His stated highest honor is a developer programming against Jev without writing example queries, trusting it enough to stay in flow. Every additional nine matters to him, even if it is not the most valuable thing by market cap, because each one enables new applications. It is also his defense against copycats: he says reliability is what this thing is, so a benchmaxed imitation will be hard to build.

The obvious objection is the long tail. A host argues that the real world is heavy-tailed, that we lack the data, and that this is why AI stays on math and code. The host's own support example sharpens it. A company claimed to answer 95% of help desk calls, but they were all password resets, and by uniqueness it was around 50%. Diogo does not entirely buy the data argument. He concedes the long tail exists but says the canary test does not require automating it. His answer is pragmatism: automation is an investment and an ROI decision, in the spirit of the programmer who spends 10 hours so a five-minute task never recurs. He does not square this with the password-reset example, which suggests the easy part may be smaller than it looks.

He is also candid about limits. Asked for his favorite use cases, he says he is not sure they work, and he wants them running in the background so nobody gets paged. He will not promise Jev is ready for the applications that have been over-promised. The hosts raise state consistency, durability and strong guarantees. He allows that over time this could become a smart database, even something near air traffic control, but calls that a little scary. His philosophy is to automate the easy work first. He expects many nines to be needed in the guts, even though adoption starts at the first layer.

One consequence he likes is for SaaS. Coding agents set off the SaaS apocalypse story, yet SaaS companies embraced Jev. Diogo thinks the story panned out poorly: software may be cheap, but it is not easy to replicate. He expects what he calls an "inverse sasspocalypse", because incumbents already know which workflows to automate and have paid to reach their users. Coding agents, by his own account, are decent at syntax, bad at semantics and incredibly bad at architecture, and Jev probably sits outside what they were trained on.

The unresolved question is whether nines can be earned deep enough. Diogo says he is fighting for them and refuses to over-promise. If reliability is the real gate, the claim that the long tail and missing data are not is still waiting for evidence from the guts of real systems.

**The open question.** Diogo dismisses the data and long-tail explanations for why real-world automation lags, and says the intelligence for rote work has been in the models "for quite a while". Yet he also says he cannot name favorite use cases because he is not sure they work, and he concedes that deeper guarantees such as state consistency and durability remain open. If reliability is the blocker, the claim that data is not is untested until Jev holds up in the guts of real systems. Watch whether anyone programs against it without example queries.

Watch the full video at [https://www.youtube.com/watch?v=Ut3LOjKNJaE](https://www.youtube.com/watch?v=Ut3LOjKNJaE&ref=nnutshell.com).