Before AI
I've been coding since long before AI assistants became part of the normal development process, and sometimes I think people who started coding recently have no idea how different the experience was.
When something didn't work, there was no ChatGPT to paste the code into and ask what you were doing wrong. You had your code, an error message, a browser, a terminal, some documentation, and Google. Maybe you'd find an answer on Stack Overflow. Maybe you'd find a three-year-old blog post written for a completely different version of the software. Maybe you'd find nothing useful at all.
So you learned to debug.
I don't mean just fixing errors. You learned how to actually investigate what was happening. If a database query wasn't returning what you expected, you checked the query, then the parameters, then the data. If an API call failed, you looked at the request and the response instead of assuming the API was broken. If something worked in one place but not another, you started comparing everything you could think of until you found the difference.
A lot of the time, the problem turned out to be somewhere completely different from where you first thought it was.
That was probably one of the most frustrating parts of learning to code, but also one of the most useful.
You couldn't just ask for the answer, so you became good at finding it.
You also became very good at reading things you didn't necessarily want to read. Documentation. Source code. Logs. Error messages. Database output. Configuration files. Old code written by someone else. You had to understand enough of all of it to work out what was actually happening.
And you made a lot of mistakes along the way.
You'd change something, run it again, discover that you'd made things worse, undo it, try something else, and eventually get to the point where you could explain the problem instead of just knowing that it was broken.
That's something I still value today.
AI has changed this completely, and I use it just like everyone else. If I'm working with something unfamiliar or I've got a problem I've never seen before, I can get a useful starting point almost immediately. It can explain code, suggest possible causes, generate a first implementation, point out things I missed, and save a ridiculous amount of time.
But I don't think that means the old skill became irrelevant.
Actually, I think it became more important.
Because AI can be wrong.
It can confidently suggest a fix that looks perfectly reasonable but doesn't actually address the problem. It can misunderstand your code. It can make an assumption about your environment that isn't true. And if you don't understand what you're looking at, it's very easy to accept the answer and move on.
That's where all those years of debugging still matter.
You learn to question the answer.
You look at what the code is actually doing. You check the inputs and outputs. You reproduce the problem. You test the proposed fix instead of assuming it works because it sounds convincing.
The interesting thing is that AI didn't really change what programming is about.
It changed how quickly you can get through the mechanical parts of it.
The underlying skill is still being able to look at something that doesn't work, resist the temptation to guess, and figure out what is actually happening.
I'm glad I learned that before AI existed.
Not because I think coding was better back then. It wasn't. It was slower, more frustrating, and there were plenty of times when I would have happily had something explain the problem to me.
I'm glad because I had to develop the habit of investigating things myself.
That habit is still probably one of the most useful things I have as a developer.
