Learning Programming in an Age of LLMs

A while back Claude went down in the middle of a somewhat frantic initial deployment of a product to production at a company where a friend of mine works. And suddenly nobody was able to do anything. Because nobody had actually read the code and had no idea how it worked.

So essentially: much of their day to day work now depends entirely on the availability of a couple of frontier LLMs.

I live in a country where those things are not regulated and you have to be really careful to not buy something that would send you to the hospital.

But realistically speaking, choosing LLM programming ultimately means pouring out an enormous amount of code, and it's difficult to verify all of it. Common sense says that if you produce 10,000 lines in an hour, you can't read all of it, and even if you do read it, you'd have to rewrite it. The problem is that LLM code differs from human abstraction. Or more precisely, it lacks a programmer's habits, so it's hard for me to maintain.

Clearly, programming in the LLM era will be different. The problem is that I can't get a sense of what that way of doing things actually is.

I think that low-priority frontend work will probably be handled by LLMs, while only complex animation work will be handled by humans, and humans will end up working only on things like payment modules, which are hard to fix if something actually goes wrong.

LLMs are now better at optimization than most people.

In my experience, people learn programming languages best by overcoming frustrating roadblocks. You often end up learning something important, even if it’s just about your mindset or approach, that landed you there. This is the difference between someone with a wet signature on their comp sci diploma and someone with a few years under their belt.

A lot of people start with tutorials and cargo-cult their way through solving their first problems, but eventually need to learn how to do things the tutorial code can’t. It seems like the AI coding tools can could perpetually make things that could be bashed together well enough to sorta solve a problem and think “oh I’ll just learn about that later,” and then never learn about it at all. If your goal is to make some quick tool to help you with something at work in a different field, well, touchdown. If you’re trying to learn the language, fail.

I read the document and sometimes use LLM as a quick search engine because I am tired of every query on google that use AI to summarize

The project goes slowly but seems the basics I grasped over the years help a lot

So perhaps it still worth to learn by hand with trial and fail

I agreed with the author that one must learn deep above the abstraction and I truely think programming still a thing even the agentic coding is getting powerful