Software developers still matter in the age of AI. Here’s why.

The fear is real: that AI will automate away the craft we’ve spent years perfecting, that our expertise will become obsolete overnight, that we’ll be replaced by systems that can generate code (and systems) faster than we can read (or understand) it.

Technology transforms professions but it doesn’t eliminate the need for your very human judgment, creativity, and expertise.

We are people who program, people who build. Most lines of code I’ve written will never run again. Not because of AI, but because someone else refactored, rewrote, or just threw that code away. But I still feel proud that my contributions were meaningful steppingstones to the present state.

We’re entering a golden age of being creative stewards of interactive technology—the stuff that powers everything from your morning coffee maker to the special effects in blockbuster films.

Developers are not becoming obsolete. We’re becoming the translators between human intention and digital reality.

As a developer and writer with my own unique mix of skills and weaknesses, I rely on a diverse collection of people, tools, systems, processes, and resources to achieve or even articulate my goals. But I also appreciate chance: the possibility that my project won’t work out, that the game will change mid-play, that the code won’t work how I want, that the words read better when shuffled randomly, that I can still be shocked by unexpected creativity.

AI is just another tool in that diverse collection. A powerful one. But still a tool that needs a craftsperson to wield it.

What can developers do that AI can’t? What we've always done: we bridge the gap between human needs and machine capabilities.

AI can generate code, but it can’t understand the full context of why that code needs to exist. It won’t feel the frustration of a user clicking through a broken workflow. It can’t make the strategic decision to refactor an entire system because it senses that technical debt is about to strangle the team’s velocity. It can’t look at a feature request and immediately know it’s solving the wrong problem.

One day our copilots will understand when we’re asking for a pattern to build n things, we aren't asking it to write n duplicative functions to handle it. But until then, it’s your job to notice. And coach. Or intervene. Or guarantee it won’t happen again.

These are fundamentally human capabilities that require lived experience, empathy, and the kind of pattern recognition that comes not from training data, but from shipping software that real people use.

When AI gets it wrong—and it will—developers are the ones who recognize the wrongness and know how to fix it. We’re the ones who can smell bad code before it’s even written, who understand the downstream consequences of architectural decisions, who can balance the competing demands of performance, maintainability, and user experience.

AI-assisted development invites us to dream bigger, weirder, and to let this new pair programmer take the wheel now and again.

There may be no I in TEAM but you can’t miss that I in AI.

When you’re working with LLMs and passing the baton to automatons, they become part of your team. The machine doesn’t replace you, it empowers you to do more, dream bigger. LLMs also deliver a chance to view your same dream from dozens of different perspectives, picking and choosing from the results.

Abstraction becomes your superpower. You’re a pattern-sensing creature who knows boilerplate code when you see it. You skim. You look for the business logic, the binding spells of inputs and outputs and phase transitions. You know you’re just as responsible for the code you didn’t read as the code you wrote yourself. It doesn’t matter where you found or imported the code or how it was generated. It’s your responsibility, and, I honestly hope, your joy.

When it comes to your code, or the pair programmer now virtually beside you, you own your rejections. You own your approvals. And you own the metamorphosis. And the bugs. The heartache. And then, the paycheck.

Working with copilots and agents encourages us to take turns as watchers and doers, learners and instructors. To become great teachers of what we think and what we prefer, not what we know. Understanding and articulating your preferences is the only way to get what you want.

We must creatively describe the conditions from which good software will emerge.

Think of it like this: you’re a DJ selecting tracks from an infinite record collection. You build a playlist of your own design with an appreciation for the ingenuity of your peers and the past. You’re remixing deep cuts from open source, freeware, shareware, and it all feels like it’s coming out of nowhere. The magic isn’t in the individual tracks—it’s in your ability to sequence them, to know what comes next, to read the room and adjust the vibe.

Copilots may give you the illusion they can do all the work themselves. But just as with pair programming in fads past, sometimes you’ve got to switch back and forth to get to where you’re going. But you’ll be OK. With your understanding of the abstractions that make computer programs, you’re a pattern-forming creature, too. Patterns networked together are systems by any other name.

When I can safely rely on automation, I not only get time back but I lose all kinds of wicked worry. And that combination is a potent catalyst for my creativity.

We all have work that we know needs our loving touch, maybe even a little bit of our sweat and a tear or two. That’s the work we should reach for. There’s always work that haunts us. Not because it’s compelling work, but because it is tedious. That’s the work I let go of and let AI take one for the TEAM.

Instead of spending hours writing boilerplate CRUD operations, you can focus on the architecture that will make your application scalable. Instead of debugging syntax errors, you can think about user experience flows. Instead of manually updating documentation, you can design systems that solve real problems.

Your favorite copilot will occasionally do the wrong thing, and when that happens, your knowledge and ingenuity is going to get you out of that pickle by course correcting code on your own, or by instructing towards possible solutions.

Eventually, your favorite copilot won’t need you to coach it through the breaks as much. You won’t have to micro-manage your new artificial worker. You’ll stop negotiating with the bots and start talking shop with the shop itself. If you don’t know the next feature to build, maybe it does.

But even then, you’ll still be the one making the final call. You’ll still be the one who understands the business context, the user needs, the technical constraints, and the strategic priorities. You’ll still be the one who can say “no” when the AI suggests something that seems clever but misses the point entirely.

Pair programming with a copilot opens your mind to possibilities you wouldn’t otherwise think of. You learn what you know as you codify it into instructions or educational material. And you learn what you don’t know as you internalize ah-ha moments that change you forever.

Your experience will guide you to next-level possibilities with the time, energy, and creative possibilities you get back. Letting AI handle the routine tasks lets us focus on the system, the outcomes, and embracing just enough chaos to evolve.

The age of AI elevates our craft through deeper collaboration. Instead of becoming obsolete, we refine our roles as architects and guides, drawing from the rich history of development to build alongside powerful new tools. We remain the essential bridge between human intention and digital reality, working in concert to turn visionary ideas into a shared, living digital world.

And that, more than ever, is work that matters to me.