I’ve been sitting with this question for a while now, mostly because I keep catching myself in the same trap: opening a chat window, describing what I want, watching code appear, and then… just accepting it. It works, so I move on. And every time I do that, a small voice in the back of my head asks what exactly I’m being paid for anymore.
The answer I’ve landed on isn’t that programmers become obsolete once AI can write functions faster than we can type them. It’s that the job quietly moves up a level. The keyboard time shrinks. Everything around it gets more important.
The first thing I’ve had to get better at is actually saying what I want. It sounds trivial until you notice how much of programming used to be figuring out the spec while writing the code. You’d start typing a function, realize halfway through that you hadn’t thought about what happens with an empty list, and fix it on the spot. When the AI writes the first draft, that discovery has to happen before you hit enter, or it happens silently in code you didn’t scrutinize closely enough. So I’ve started writing out edge cases and constraints almost like a mini design doc before I ask for anything. It feels like overhead at first. It isn’t — it’s the same thinking, just moved earlier.
The second thing, and the one I think most people underrate, is reading the output like you don’t trust it. Not because AI is bad at this, but because there’s a specific kind of danger in code that looks right. When you write something yourself, you carry a working model of it in your head; you know where the bodies are buried. When AI hands you a finished function, you don’t have that model for free. You have to build it by actually reading, tracing the logic, and asking “what would break this?” instead of skimming it and firing off a mental checkmark because it compiled. I’ve shipped bugs I wouldn’t have shipped if I’d written the code myself, purely because reviewing feels like less work than it is.
Testing has become non-negotiable in a way it never quite was for me before. When I wrote every line, I had some intuition for what to test because I remembered every decision I’d made. Now that intuition is gone, so the tests have to do the job my memory used to do. I’ve gotten more disciplined about writing them myself rather than asking the AI to write both the code and the tests that check it which always felt a little too much like grading your own homework.
The part of the job that hasn’t moved an inch, and honestly feels more valuable than ever, is system-level thinking. Where should this logic live? What’s going to be painful to change in six months? How do these three services actually fit together? AI tools are genuinely good at solving the problem in front of them and pretty bad at holding the whole system in their head the way a person who’s lived in a codebase for a year can. That’s still ours to do.
And then there’s a quieter worry I don’t see discussed enough: what happens to your instincts if you stop exercising them. Debugging a gnarly production issue at 2 a.m. still requires a kind of fluency that comes from having written and broken a lot of code by hand. I’ve started deliberately keeping some of that muscle alive writing things from scratch sometimes even when I don’t strictly need to, just so I don’t wake up one day only able to prompt and approve.
If I had to put it in one line: AI didn’t remove the thinking from programming; it removed the typing. What’s left is the part that was always the actual job: deciding what should exist, checking that it’s right, and understanding it well enough to fix it when it isn’t.
