AI Is Extremely Useful. And Massively Overhyped.

I have a slightly boring opinion about AI: it's incredibly useful, and it's also massively overhyped. Both things can be true at the same time.

In fact, if you're reading this on my website, there's a decent chance that parts of the website you're looking at were written with the help of AI. And I think that's worth being upfront about.

But there's an important distinction. This wasn't a case of me typing "make me a website" into a chatbot and accepting whatever came back. The code was written by a programmer who understands what the code is supposed to do, what architecture makes sense, what the constraints are, and what good practices look like, with AI helping along the way. That distinction matters.

I honestly think that not using AI as a programmer today is becoming comparable to refusing to use a programming language when we moved beyond writing programs directly in machine code. Maybe that's an exaggerated comparison, but the productivity difference is getting hard to ignore.

I can do things with AI now that would have taken considerably more time before, and some of them aren't particularly exciting things either, which is actually the point. Say I get a ticket asking me to change something in a part of the codebase I've never touched before. Traditionally, I'd have to dig through the project, figure out how the framework works, trace a few calls, search for similar implementations, maybe find some documentation, and eventually ask someone who knows that part of the system what I'm looking at. Now I can describe roughly what I'm looking for and let AI search through the code with me.

Is it always right? Absolutely not. But it's often right enough to get me to the interesting part much faster.

That's where I think AI is genuinely excellent: finding things, recognizing patterns, following patterns that already exist, suggesting implementations, explaining unfamiliar code, working out what an exception probably means, writing boilerplate, and increasingly, replacing the role that Stack Overflow used to play for me. That last one is probably one of the most obvious changes, I don't particularly miss spending twenty minutes searching through old Stack Overflow answers hoping somebody had the exact same problem with the exact same version of some library. AI is usually much better at taking my particular problem and giving me something to start from.

But there's a catch. AI is really good at reproducing patterns that already exist, which means the quality of what it produces depends heavily on the patterns it has to reproduce. If your codebase has good conventions, clear abstractions, sensible architecture and consistent practices, that's great, AI has something useful to work with. If your codebase is a disaster, AI can become remarkably efficient at producing more disaster.

There's another problem I've noticed. Because AI makes the easy stuff so much faster, you can start doing a lot more of it, suddenly, producing another API endpoint, another CRUD screen, another DTO, another test, another wrapper, another integration, another 500 lines of perfectly plausible code feels almost free. That's where I think developers need to be a little careful: you can get a strange sense that you're being incredibly productive simply because you're producing an enormous amount of code.

But producing code isn't necessarily the difficult part of programming. The difficult part is figuring out what the code should actually do, understanding the problem, understanding the business rules, understanding the weird exception that exists for a reason nobody documented, knowing which abstraction is going to make the next five changes easier and which one is going to make them miserable. That's the part where I still don't trust AI to simply take over.

And I don't necessarily mean that AI is incapable of writing the code, quite the opposite. I'm pretty sure it can implement a surprisingly large number of complicated things if you give it enough context. The problem is the interface between the human and the machine: we're still not particularly good at telling a computer exactly what we mean.

We can say "build this thing," and AI might build something astonishingly close to what we had in mind. But close isn't the same as correct. There's always some assumption hiding in there, some requirement we didn't think to mention, some edge case we forgot existed, some decision that seemed obvious to us but wasn't actually communicated. And the more complicated the problem becomes, the more those little gaps matter.

That's why I don't really see the future of programming as "developers disappear and AI writes all the code." I see it more as developers getting a much more powerful tool for producing and manipulating code. The amount of code one developer can work with is going to keep increasing, which is fantastic, but it also means that understanding the code becomes more important, not less. If AI can produce ten times as much code, you don't necessarily want to become a developer who reviews ten times as much code line by line. You want to become better at knowing which code should exist in the first place.

There's a useful analogy here with autopilot. Planes have had increasingly capable autopilot systems for decades, and yet we still put pilots in the cockpit, not because the plane can't fly itself, but because somebody still needs to be responsible for the flight. The same applies to software, although the consequences obviously aren't quite the same as falling out of the sky. Someone still has to be responsible for what gets shipped, decide whether the implementation actually solves the problem, and notice when the AI confidently made a completely reasonable decision that happens to be wrong for this particular system. And sometimes, someone just needs to look at the result and say, "No. We're not doing it this way." That's still the programmer's job.

So yes, I use AI. A lot. I'd be pretty silly not to, it saves me time, helps me explore unfamiliar code, catches things, gives me ideas, and removes a huge amount of tedious work from programming.

But I don't think that makes programming less important. If anything, it raises the bar: when writing code becomes cheap, knowing what code is worth writing becomes more valuable. And that's probably the part of the AI conversation I find most interesting.