AI code agents and Typed Languages

Like many engineers who started working in the 2000s, I started my programming journey with a statically typed language: Java. And honestly, the experience couldn’t have been worse. I still remember my early days. I spent far more time fighting with types than actually implementing real functionality. Types felt like an obstacle, not a safety net.

That’s why, when I finally discovered Ruby, a dynamically typed, non-compiled language with a beautiful, expressive syntax, I fell in love instantly. It felt liberating, productive and fun. Ruby represented everything I thought programming should be.

Over the years, though, my relationship with types slowly changed. To the point where today, if I’m honest, I actually prefer them when doing serious work.

I think the real turning point for me was the arrival of TypeScript. Not because it was “typed JavaScript”, but because it got some key things absolutely right, especially type inference and code editor support. Suddenly, the whole typing experience became much more developer-friendly. You got the benefits types were originally designed for: better documentation, catching errors at compile time, safer refactors, and smoother library upgrades, without all the bad things I remembered from my Java days.

And then we arrived at the current era: AI, code generation, and autonomous agents that write software.

To my own surprise, I’ve had to admit something interesting. Systems that generate code for typed languages, like TypeScript, or modern Python when you actually use type hints, tend to perform significantly better when producing large chunks of code autonomously. Not always, but often enough to be noticeable.

The reason is fairly straightforward: many of these tools have type-checking built directly into their agent loops. While they’re writing code, they can validate whether the types are correct. This gives them a much deeper understanding of the code they’re producing and helps them avoid a whole class of errors upfront. The result is less back-and-forth with the developer and far more usable output from the start.

When I test new code editors and they don't have type checking built in their Agent loops I notice it immediately and I stop using them. This is what it happened to me with Antigravity from Google when they launched it.

And this is why I firmly believe that the rise of AI is going to push dynamically typed languages in a very specific direction. Sooner or later, they’ll need to adopt some form of typing in their standard libraries. Not necessarily to abandon their philosophy, but to coexist with a new reality.

AI-powered code editors and agents are here to stay. We’re going to use them more and more because, frankly, they’re incredibly convenient. And for them to truly shine, types are not a burden, they’re a superpower.