See pricing
AI Can Write Code. Why Isn’t Software Better?
The a16z ShowAI

AI Can Write Code. Why Isn’t Software Better?

TypeSafe AI's founder says coding agents only produce the same old software faster, so the real prize is putting reliable intelligence inside software itself. His yardstick is blunt: if AI is this smart, where is all the automation?

September 28, 2026 · 43 min listen · 11 min read · Diogo Almeida
0:00
–:––

Context

Ben Horowitz and Martin Casado of a16z talk with Diogo Almeida, founder of TypeSafe AI. His company makes a product called Jev (the transcript spells it several ways, so the name here follows the episode description). Diogo has a background in Kaggle, Google Brain and OpenAI, and he now argues for a different use of AI: not writing code, but living inside code. It matters to PMs because most AI features today are a chatbot bolted to the side of a product, and this episode explains why that pattern keeps stalling and what a deeper alternative looks like.

The Big Idea

Coding agents make the same kind of software faster. The bigger opportunity is a new building block that puts reliable intelligence inside the software, so programs can act on intent and not just hand text to a human.

Diogo's test is simple: AI is very smart, yet very little real work is automated. He thinks reliability, not impressive demos, is the missing piece.

Key Insights

Coding agents write old-style software

Diogo likes Claude Code, Codex and Cursor. He borrows a description of them as "just in time software": they make software on the fly, but that software has the same expressive power as software always had.

  • What: the output is still ordinary code, the same as a human would write ten years ago.
  • Why it matters: faster typing does not add new capabilities to a product.
  • His alternative: "instead of automating software engineering, I want to expand what software itself can do."

Faster code is not better software

Diogo says that no matter how many coding agents you use, "the software actually isn't getting better." Maybe you ship faster, and it may even get worse with less oversight. Martin adds that it can also be more insecure, and that the average pull request at a large company is only about 10 lines. Automating those 10 lines optimizes something small and adds no new product capability.

Intelligence as a primitive inside code

Whether a human or a coding agent writes the program, Jev is something you place inside it. The team describes it as follows:

  • A library where you describe what you want in natural language.
  • You give it a state machine (the set of states your program can be in).
  • It chooses what to do, with confidence levels, which programs have not had before.

Diogo notes that the input is deliberately called "state", because the goal is the inside of programs, not the chat window at the edge.

Reliability means three different things

Asked what reliability means for a model, Diogo separates it into parts:

  • Uptime: availability and service level agreements. This is not his main concern.
  • Determinism: the same output every time. He says it helps unit tests but not real systems.
  • Robustness: "similar intelligence every time." The answer may differ, but it should be smart every time.

His highest bar is that developers can program against it without writing example queries, because they simply trust it. He says every added "nine" of reliability enables new applications.

Why AI never fit inside software

Martin describes how AI has been "ships in the night" with software. Software does not take natural language, and models ignored requested JSON schemas. So teams ended up giving output to a human (a chat) or to another LLM (the agent while loop). He described a "five stages of grief" pattern in teams trying to embed AI, ending with acceptance and handing the output to a person anyway. Jev's pitch is that an LLM can be mapped to a state machine productively.

Automate the boring work first

Diogo wants to start with tasks nobody wants people to do, not showy outliers. He says the industry has fallen into anti-patterns of chasing outliers and impressive use cases. He wants automation that runs in the background and that someone would trust "to run and not page them."

  • He points out that OpenAI has been trying to automate customer service since 2020.
  • Martin adds that older support automation claimed to answer 95% of calls, but most of those were repeated password resets. By uniqueness the real share was closer to 50%.
  • Diogo's canary in the coal mine: math benchmarks are solved, "but we still can't handle a drive through."

SaaS may win, not die

Diogo argues the "SaaS apocalypse" story, where software is cheap and easy to copy, has panned out poorly. A lot of value sits beneath the hood. He thinks large, boring SaaS companies are best placed because they know which user workflows need automating and already reach all their customers. He calls it an "inverse SaaS apocalypse", where existing apps become dramatically more useful.

Mental Models & Frameworks

Human loop versus while loop

Martin's framing of the two default ways to use AI. From first principles, natural language output must go somewhere: to a human (chat) or back into another model (the agent while loop). Jev tries to add a third option, where the output is a decision a program can use directly. Use this as a check on any AI feature: who or what consumes the model's output?

Language in, state machine out

Martin asks whether there is a slider between language in and language out (today's chat) and a fully imperative program. Diogo says the answer in his heart is that it is a slider.

  • Intelligence per dollar: his current North Star, though he says it could be wrong. Intelligence per second might matter more in the short term.
  • Where it sits: because answers must arrive in milliseconds, it will look more like a database for a while than a standard library. He would like it to become a standard library too.

Probabilistic programming returns

Diogo expects a new era of probabilistic programming, where programs make decisions with probabilities and confidence. Martin notes that the field had a long history before it faded in the 1970s. Diogo also says Jev is "absolutely a classifier", and guesses it may beat having an ML engineering team from 2019 build narrow models for you, since few teams then could collect datasets and measure them well.

Venn diagram of AI and code

On day one of onboarding, Diogo draws a Venn diagram: what AI is good at, and what is valuable in code. The product lives in the middle. For example, it does not output extrapolated floats, because AI is bad at that. Products that respect this overlap avoid asking a model to do what it does poorly.

Decision Principles

Principle: Automate easy work before hard

  • When: choosing where to put AI first, for example in high-stakes systems such as air traffic control.
  • Why: Diogo's philosophy is to "automate the easy work before the hard." Reliability is an investment, so each automation should be an ROI decision.

Principle: Put intelligence in the guts

  • When: deciding whether AI belongs at the user-facing layer or deep in a system.
  • Why: Diogo works backward from a future with AI everywhere and asks what share of calls are for human consumption versus internal. He expects many "nines" of reliability needed in the internals. He says it starts at the first layer, but if you do not aim for the guts, getting there will take a while.

Trade-offs & Nuance

Architecture speed versus quality

Diogo says coding agents are good at syntax and "incredibly bad at architecture", which he calls the most human creative part of software. He allows that models may be 50th percentile at architecture, which is fine for someone who knows nothing about it. It is a real trade-off: a company may accept 50th percentile architecture instead of 60th to move faster, such as having Codex work overnight.

Real-world long tail

Martin questions whether the real world is heavy-tailed, with many exceptions and little training data. Diogo agrees there is a long tail, but does not fully buy the data argument. His view is that we need not automate the tail. We should be pragmatic and automate the simple, repeated work first.

Where Jev may not work yet

Diogo is careful not to overpromise. He says he does not know if Jev is ready for all the applications that have been overpromised. He also notes open questions about how deep this goes on systems-level guarantees such as state consistency and durability (Martin's point), where strong guarantees are needed. Analyzing logs or emails, or talking to a human in a UI, are clearer fits.

Common Mistakes

Mistake: Optimizing models for human judges

Diogo says that since RLHF, the industry split into gigantic overpromise and underdelivery. Humans evaluate how good models look, so the field has been optimizing the judge and not the automation. The better approach he suggests is to measure to what extent a model can automate real, productive tasks.

Mistake: Adding only a chatbot

Martin says the most software can do today is add a small chatbot at the side that takes some actions, but not all, because some actions are not reliable enough. Software has barely changed in ten years even though AI has changed a lot. The fix is to make the software itself better, not only to add a chat panel.

Practical Application

Test features against the automation bar

Take your product's AI features and ask Diogo's question: what work should now be automated that is not? List tasks that are simple, repeated and disliked. Use them as your canary, in place of demo-friendly use cases.

Ask who consumes the output

For each AI feature, write down whether a person, another model, or your own code reads the output. If it is always a person, look for a decision in your product where a probability and a confidence level could drive the next step directly.

Define reliability before shipping

Split reliability into uptime, determinism and robustness, as Diogo does, and set a target for each. For an AI step in a workflow, decide whether "similar intelligence every time" is enough, or whether you need identical output for testing.

Look for form-filling to replace

Diogo hopes multiple-choice forms disappear, because they map natural language the software already has into structured output. Audit your product for forms and dropdowns that exist only because software could not read intent, and mark those as candidates for intent-based input.

Questions to Consider

  • Which tasks in your product would a customer trust to run in the background without paging anyone, and which AI features today only produce text for a person to read?
  • If a coding agent wrote your next feature, would the result do anything your product could not do ten years ago, or just do it faster?
  • For your most important AI feature, do you measure uptime, repeatability of output, and consistent quality separately, and which one do users actually feel?
  • Which forms or multiple-choice screens in your product exist only because software could not understand what a user meant?

Bottom Line

Diogo Almeida argues that coding agents speed up making the same software, while the real gain comes from embedding reliable intelligence inside programs. Reliability, meaning consistently smart behavior, is what turns AI from a chat tool into automation that people trust to run on its own.

Resources Mentioned

ResourceTypeWhy it was mentioned
typesafe.aiWebsiteThe company site for TypeSafe AI, listed in the episode notes for learning more about Diogo's company.
Diogo Almeida on X (@CompleteSkeptic)Social accountListed in the episode notes as the place to follow Diogo.

Concepts to Explore

Probabilistic programming

Programming where results carry probabilities. Martin notes it has a long history that faded in the 1970s. Diogo expects a new era of it now that models can make decisions with confidence levels.

Fourth generation languages

Martin compares the idea of replacing forms with intent to the 4GLs of the 1980s. Diogo's "do what I mean" goal is a modern version of that dream.

Case Studies Mentioned

Customer service automation attempts

Diogo notes OpenAI has tried to automate customer service since 2020. Martin adds that earlier help desk vendors claimed to answer 95% of calls, but most were password resets, and by uniqueness the real share was around 50%. The lesson: headline automation rates hide a long tail of exceptions.

Voice control decision demo

Diogo shared a Jev use he found cool but was unsure was reliable: someone using voice to control a computer, with the model constantly deciding whether the speech was a command or text to insert. His point is that interfaces could change if this became cheaper and faster.

People to Follow

Diogo Almeida

Founder of TypeSafe AI, maker of Jev. He describes himself as a computer scientist first, and worked at Google Brain and OpenAI before starting the company.

Martin Casado

a16z investor and co-host, who pushes the discussion on how Jev differs from coding agents and on the limits of automation.

Notable Quotes

"Where the fuck is all the automation?" (Diogo Almeida)

"Instead of automating software engineering, I want to expand what software itself can do." (Diogo Almeida)

"It doesn't matter how much AI coding agents you use, the software actually isn't getting better." (Diogo Almeida)

"Imagine if all technology just did what you mean." (Diogo Almeida)

AI PM course

Everyone hears the same episodes.
Few can do what they describe.

Start for free