Learning to code before AI became the default.
I started teaching myself to code in 2018. What I remember most is how long I spent not understanding anything.
The loop went like this. I was teaching myself HTML, CSS, and JavaScript, building little weather trackers that pulled a forecast from an API and put it on a page. Something would break. I'd read an error message that may as well have been written in another language, search it, land on a Stack Overflow thread from 2013, paste in the top answer, and watch the problem disappear without learning a thing. That worked until it didn't. The first time I picked up Python, the bug wasn't in my code. It was the interpreter, the thing actually running the code, and there was no answer to paste because I didn't yet understand what I was even looking at. I had no choice but to sit there until I did.
That was the real education — not the tutorials, but the part where I was stuck with no way out except through.
There was no shortcut in 2018, which turned out to be the best thing about it. You couldn't ask a machine to explain the bug or to just fix it. If you wanted working software, you had to build a model of how it worked in your own head, because nothing else would hold it together. The struggle wasn't in the way of the learning. The struggle was the learning.
Then the shortcut arrived. GitHub Copilot became generally available in 2022, ChatGPT landed that November, and within a year you could describe what you wanted in plain English and get back code that ran.1 The step where you used to build the model became optional. Most people, reasonably, skip it. Why spend three hours understanding something a model will write in three seconds?
It took me a while to say the problem with that cleanly:
You can outsource your thinking. You can't outsource your understanding.
Thinking is the part that produces the artifact: the lookup, the syntax, the first draft of the function. A model does that now, often better than I would. Understanding is the model in your head, the one that lets you read a block of code and know whether it's any good. A prompt doesn't put it there, and nothing transfers it to you. You either built it or you didn't.
That's what slop really is: not code that looks wrong, but code shipped by someone with no way to tell. If you never built the model, you can't review the output. You can't catch the mistake the AI made confidently. You accept whatever runs, because "it runs" is the only test you have left. Do that across a codebase and you end up with software nobody understands, including the person whose name is on the commits.
I'm glad I learned before any of this existed, and not out of nostalgia. The understanding I paid for in 2018 is the one thing the shortcut can't hand anyone. I use AI every day now, but it sits on top of a foundation that was already there — I can tell when it's wrong because I once had to be right the slow way.
A while back I wrote that building something makes understanding stick in ways reading doesn't. The same is true of prompting. Watching a model produce a working function teaches you about as much as watching someone else lift weights.
The people most exposed are the ones starting now. They can ship something that works on the first day and never once feel the pressure that used to force them to understand it. The friction is gone, and the friction was the part doing the work.
The typing was never the job. The typing is the part it's safe to give away. Understanding is the part you still have to earn, and no model has figured out how to earn it for you.
Footnotes
-
GitHub Copilot entered technical preview in June 2021 and became generally available in June 2022. ChatGPT launched on November 30, 2022. The shift from autocomplete to "describe it and get a working draft" played out over roughly the following year. ↩