# AI and the Developer: What I've Been Thinking, Between Opportunity and Crisis > Source: > Published: 2026-06-04 06:20:42+00:00 "The best way to predict the future is to invent it."— Alan Kay For the past few months, one question keeps circling back to me, and I still can't answer it: **am I still necessary?** Not the reckless, late-night kind of anxiety you get from reading a sensational tweet. Something quieter. A low hum that shows up in the moments when I hand off a whole task to an agent — not a single line, but the entire thing: read the codebase, plan, write, run the tests, fix what broke — and it just... does it. I gave a nudge, a sentence or two of direction, and watched it carry the work to the end. A strange feeling: relief and a small grief, at the same time. This post isn't a prediction about the future. I don't have the authority for that. It's just what one ordinary developer has been thinking, fearing, and — eventually — making peace with. I remember the first time I handed an agent a real task — not a snippet, a whole task. Not to show off — because a deadline was breathing down my neck. I needed a feature added across an unfamiliar codebase: a new endpoint, the data layer behind it, validation, tests. Normally this would cost me a couple of days: trace how the existing code is wired, read the docs, try, fail, Google, copy something off Stack Overflow, then bend it all to fit. This time, I wrote a few sentences describing what I wanted, and let it run. It read the codebase on its own. It made a plan. It wrote the code, ran the tests, saw two of them fail, and fixed them — without me. I mostly watched. It wasn't perfect. I nudged it once or twice. But it carried the work to the end, to a degree that was almost **unsettling**. In that moment, I didn't feel as happy as I'd expected. I felt something closer to sadness. Those couple of days of "wrestling" — the thing I secretly took pride in, the feeling of conquering a hard problem — had just collapsed into a few minutes of me reading a diff. The struggle wasn't shrunk; it was handed off entirely. The emotional reward was gone. Only the result remained, and a question of where, exactly, I had been in all of it. And I asked myself: if the hard part, the part that makes me *feel* like a programmer, is being done for me by a machine — what's left of me? Everyone talks about the opportunities. And they're not wrong. **AI removes the friction tax of starting.** The hardest part of many tasks isn't the doing — it's overcoming the initial inertia: the blank screen, the syntax you've forgotten, the boring boilerplate. AI swallows that part whole. I prototype faster. I dare to try things I used to avoid simply because they were "too much hassle." **It raises a person's ceiling.** A developer who knows a little frontend can now stand up a respectable backend. Someone shaky on DevOps can read a Terraform file with AI sitting beside them, explaining as they go. The lines between "roles" are blurring. Personally, I feel *wider* than before — though not necessarily *deeper*. **It's the most patient teacher I've ever had.** I can ask a dumb question at 2 a.m. without fear of judgment. "Explain it to me like I'm five" — and it does, for the tenth time, without ever getting annoyed. But here's the thing few people say out loud: **this opportunity is not distributed evenly.** The person who benefits most from AI isn't the beginner — it's the one already skilled enough to *know when the agent is wrong*. It does the work, but I'm still the one who signs my name to the result. That ability to *smell* a bad piece of code, to sense an architecture that'll collapse in six months, to read a diff and feel that something is off — that still lives in humans, and it comes from experience, from those days of wrestling. The irony: AI needs me to have lived through the very struggle it just took away from the next generation. When people say "crisis," they usually mean **losing their jobs**. Robots replacing humans. I think that fear is aimed at the wrong target. The real crisis, for me, is subtler. When code comes too easily, we risk *operating* systems we don't truly *understand*. The code runs, the tests are green, we ship. But when it catches fire at 3 a.m., who understands it deeply enough to save it? There's a vast difference between "this code works" and "I understand *why* this code works." AI makes that gap easier to ignore than ever before. For years, I defined myself by my ability to *write* code. It was a skill, a source of pride, the thing that set me apart from outsiders. Now the skill of "writing" is becoming a commodity. My value is shifting from *writing* to *judgment* — knowing what to build, why, and how to build it right. That's an uncomfortable shift, because it asks me to let go of part of the person I used to be. This is the one I fear most. Skills don't vanish overnight. They *atrophy* slowly — the way I forgot how to read a paper map after ten years of GPS. Every time I let AI handle something I should have thought through myself, I'm trading a sliver of future capability for present convenience. Most of the time, that trade is worth it. But if I don't make it *consciously*, one day I'll wake up and realize I've become someone who only knows how to press buttons. I don't have a tidy conclusion. But I have a few things I keep reminding myself. **One — distinguish between being lazy and being freed up.** AI handling the boring work isn't permission to rest; it's an invitation to spend my energy on what *only humans can do*: understanding the user's real problem, making hard trade-offs, taking responsibility. If I use that freed-up time to coast, that's on me — not the tool. **Two — deliberately keep my "muscles."** Now and then I turn off autocomplete on purpose and write something from scratch. Not for efficiency, but for training — like an athlete who still runs even though cars exist. Deep understanding is a muscle, and muscles need to be used. **Three — the best student is the one who asks the right questions.** In an age where answers are dirt cheap, value moves toward the *question*. Knowing what to ask, which answers to distrust, when "good enough" is enough and when it isn't — that's the skill of the future. And fortunately, it's a very human one. **Four — the tools change, the craft doesn't.** My job was never "typing code." It was always *solving problems with software*. The keyboard, the IDE, the language, the framework — all temporary tools. AI is one too. A good craftsperson doesn't fear a new tool; they learn to wield it. Let me return to the question I opened with: *am I still necessary?* I think the answer is **yes** — but "necessary" in a different sense than before. Not necessary as a fast typing machine. Necessary as someone who *cares* — cares whether the thing I'm building actually helps anyone, whether it's safe, whether it's kind. AI can generate an endless stream of code. It doesn't know *why* something should be built, and it doesn't bear the consequences when things go wrong. That void — the void of meaning, of judgment, of responsibility — still needs a human to stand in it. And I don't think that's a bad thing at all. *What about you?*