Back to the blog
AIProductivitySoftware Quality

Has AI solved programming? Why software hasn't gotten better

November 15, 2026·6 min read·Diego Horvatti

Open Slack, Spotify and your banking app. Now tell me: has any of them gotten noticeably better in the last two years? That's the question Jonathan Blow puts on the table in a recent video (watch it here). If AI solved programming, like so many people keep saying, the software we use every day should be faster, more stable and nicer to use. It isn't. And I think he's right to push on this.

Who Jonathan Blow is and why you should listen

Blow is the creator of Braid and The Witness. He has also spent years building his own language, Jai, and his own game engine. He's the kind of dev who measures frames in milliseconds and complains when a text editor takes half a second to open.

He has a track record on this topic. In an older talk, he argued that software keeps getting worse over time because each generation of devs understands less about the layers they build on. The new video is the natural follow-up to that thesis, now with AI in the middle.

You don't have to agree with everything he says. He exaggerates on purpose. But the core question is too good to ignore.

Has AI solved programming? The argument in the video

The idea is simple. If a tool makes everyone 5 or 10 times more productive, it has to show up somewhere. It should show up as better products, fewer bugs, lighter apps, and features that used to be too expensive and now ship fast.

What we see in practice is something else:

  • Electron apps using 500 MB of RAM to show a list of messages.
  • Updates that move buttons around and break what used to work.
  • Old bugs that have sat open in the issue tracker for years.

None of this has improved in any noticeable way since Copilot, Cursor and agents became the default. Blow's conclusion is that the promised productivity either doesn't exist the way it's being sold, or it's being spent on things that don't matter.

Writing code faster was never the bottleneck to making good software.

So where is the speed going?

This is where I think we can go beyond the video, based on what I see in my day to day.

AI is great at producing volume. It writes the CRUD, the form, the repetitive test, the API boilerplate. That's real and I use it every day. But code volume isn't product quality. Sometimes it's the opposite.

Picture a common scenario. You ask the agent to build a search hook with debounce. It gives you this:

export function useSearch(query: string) {
  const [results, setResults] = useState<Item[]>([])
  useEffect(() => {
    const t = setTimeout(async () => {
      const res = await fetch(`/api/search?q=${query}`)
      setResults(await res.json())
    }, 300)
    return () => clearTimeout(t)
  }, [query])
  return results
}

It works in the demo. It passes a rushed review. But it has a race condition: a slow response can arrive after a fast one and overwrite the right result. There's no encodeURIComponent. It doesn't handle errors. It doesn't cancel the fetch with AbortController.

None of these problems is hard. The problem is that AI gives you 80% in 10 seconds and you feel like you're done. The 20% that separates good software from mediocre software still needs someone who understands what's going on. Multiply that by a hundred hooks in a project and you get exactly the kind of app Blow is complaining about.

The bottleneck was never typing

Every dev with a few years under their belt knows this, but we forget. The time on a real project goes to:

  • Understanding what the user actually needs.
  • Choosing the right data model, the one you'll carry around in PostgreSQL for five years.
  • Figuring out why something is slow only in production.
  • Talking to people, negotiating scope, saying no.

Typing code is maybe 20% of that, on a good day. If AI cuts that part in half, you've gained 10% overall. That's a nice win, but it's far from the 10x you hear in launch keynotes.

And there's a hidden cost. Code you didn't write is code you don't understand as well. When it breaks at 3 a.m., the bill comes due. I've reviewed PRs with 1,200 generated lines where the author couldn't explain half of them. Reviewing that took longer than writing it from scratch would have.

Where I disagree with Blow

He tends to treat AI as something that only makes things worse. I don't see it that way.

For people who already know what they're doing, AI clears boring work out of the way. I migrate a schema, generate types, write seed scripts and set up integration tests much faster than I did in 2023. That frees up time to think about architecture and performance, which is exactly where Blow wants us to spend our energy.

The real question is what each team does with the time it saves. Most companies don't use the gain to polish. They use it to push more features, with the same tight deadlines as always. The result is more mediocre software, shipped faster. That's not the tool's fault. It's on whoever decides the roadmap.

One more thing: it's still early. New tools take years to turn into better products. The spreadsheet didn't change accounting in its first year. But early is no excuse to believe the hype right now.

What changes in your workflow

If you take the argument seriously, you can pull out a few practical rules:

  1. Use AI for what you could write yourself. If you can't, use it to learn, not to ship.
  2. Review generated code like it came from a confident intern. It writes well and gets things wrong with conviction.
  3. Measure what matters. Load time, bundle size, error rate in production. If those numbers don't improve, your productivity is just a feeling.
  4. Spend some of the saved time on quality. That old bug, that slow query, that component that renders ten times. That's where users notice the difference.

A simple test I run: at the end of the month, I look at what went to production and ask whether the user would notice the difference. If the answer is "no", I was just busy, only faster.

My take

Blow is annoying, and thank goodness he is. The industry needs people asking where the results are, because "lines generated by AI" numbers say nothing about the final product.

AI didn't solve programming. It solved typing. The rest, understanding the problem, caring about performance, having taste for detail, is still our job. And the best part is that it's exactly the part worth learning.

If you want to see how I apply this in real projects, take a look at my projects.

LinkedIn summary

Open your banking app and tell me: has it gotten better in the last two years?

If AI solved programming, the software we use every day should be faster, more stable and nicer to use. It isn't.

The reason is simple: writing code was never the bottleneck. AI gives you 80% in 10 seconds, and the 20% that separates good software from mediocre software still needs someone who understands what's going on.

And most teams spend the time they save shipping more features, not polishing. That's a roadmap decision. The tool isn't to blame.

AI solved typing. Understanding the problem, caring about performance and having taste for detail are still our job.

I wrote more about this on the blog, with a real example of generated code that looks done and isn't. The link is in the comments.

#ArtificialIntelligence #SoftwareDevelopment #Programming #Productivity #SoftwareEngineering