Some Thoughts on Coding, AI, and Staying Relevant
I’ve been hearing this statement more and more lately:
“Developers will shift from writing more code to reviewing more code.”
In a recent catch-up, I asked my colleague Josh what he thought about it.
Josh replied, “We already do that anyway—even before AI was capable of writing code for us. We’re constantly reviewing—what we write ourselves, and what our teammates write. It's just part of the job.”
That made a lot of sense. Most of the time when we’re coding, we’re reading—trying to understand the existing code before making changes. That’s why writing maintainable, clean code matters in the first place. We're not just writing for others—we’re writing for our future selves.
During the discussion, an idea popped into my mind: sometimes we ask AI to generate a not-too-bad prototype and then guide it toward where we want to go. Other times, we write the prototype first and ask AI to refine it. We switch between these two modes throughout a coding session. That feels a lot like pair programming—just with AI now.
Pair Programming with AI
I’ve always loved pair programming. I learned so much by sitting next to a teammate and solving problems together.
But I’ll admit—after a while, I got tired of it. It left me with less focused time for deep work.
Pairing is great for feature delivery: fewer bugs, faster feedback, and better knowledge sharing. But for individual learning—especially when diving deep into a topic—it’s not always ideal. You don’t want to waste your peer’s time.
That’s where AI really shines. You can write code while AI quietly reviews. You can write a test and let AI attempt the first implementation. You can explore rabbit holes without the pressure of asking “dumb questions.” You can ask for further explanation or related reading—without hesitation.
Who Is the Driver?
That said, the original question still lingered. In the age of AI, what is my value as a developer?
It made me feel less proud of being a creator. Things like “moving one function to another file” used to feel like small wins. Now they feel… disposable. And that sucks.
But then, I read DHH’s interview with Lex Fridman (highly recommend). Something he said helped me find the missing piece.
When we're working on something we already know how to do—like a refactor we’ve thought through—it’s often better to opt out of AI’s help entirely. Especially autocomplete. Instead, we should slow down and focus on typing it out ourselves. As DHH put it:
It’s such a better experience as a programmer to look up APIs, to get a second opinion on something, to do a draft, but I have to do the typing myself because you learn with your fingers — DHH
AI can easily guide us to a solution—but often a mediocre one. Autocomplete can nudge us toward what’s common, not necessarily what’s best. It works, sure—but if we’re not careful, we’ll fill our codebase with working but mediocre code. And it adds up.
We need to be the driver. We decide the direction, then ask for help when we need it.
AI should be the assistant—not the one behind the wheel.
Writing code still matters—as long as we’re thinking. The thought process behind each line is what makes us valuable. Without that, we lose the skill, the joy, and the control.