Deliberating on the Developer's Dilemma

Deliberating on the Developer’s Dilemma

The advice used to be “learn to code.” For two decades, it was the closest thing to a guaranteed path to a good career. Now AI codes too. What happens to the people who took that advice? What should you do if you were one of them?

I’ve spent decades in this industry—writing code, managing developers, building teams around the assumption that good programmers were scarce and valuable. Parts of that assumption are eroding. Not slowly, not theoretically, but right now, in ways I can see in my own daily work. Sure, it’s not perfect yet, but AI coding agents are already building features that would have taken days or weeks, and the math of developer value is changing fundamentally.

This isn’t a post about whether AI will “replace” developers. That framing is too simple. The more interesting question is: what does it mean to be a developer when AI handles the part you thought was your job?

What’s Actually Changing

Let’s be precise about what’s happening right now. AI coding tools are quickly getting remarkably good at:

Generating boilerplate and standard patterns. The CRUD operations, the API integrations, the data transformations—the bread and butter of most development work—these are increasingly trivial for AI to produce.

Translating intent into working code. You describe what you want, the AI builds it. Not perfectly, not every time, but often enough that the dynamic has shifted.

Debugging and refactoring. Point an AI at broken code, and increasingly it can find and fix the problem faster than a human can.

This isn’t automation of the “boring” parts. For many developers, this is the craft. The satisfaction of solving a gnarly bug, the flow state of building something from nothing, the pride in elegant code—these aren’t peripheral to the job. They’re why many of us became developers in the first place.

When your identity is tied to a skill that’s being commoditized, the stakes feel existential.

The Market Implications

Before we talk about what developers can do, let’s be honest about what’s happening to the market around them.

For consumers of software: More software, faster. Lower barriers to getting custom solutions. This sounds good, and mostly it is. But also: at least in the short term, more mediocre software flooding the market, more security vulnerabilities from AI-generated code that nobody fully understands, more churn as the cost of switching approaches zero, more options making choices more complex. The abundance creates its own problems.

For businesses: Development becomes a smaller line item, which sounds like savings until you realize it shifts the bottleneck elsewhere. When code is cheap, the question “what should we build?” becomes the expensive one. Strategy, product sense, customer understanding, support—these don’t get cheaper just because implementation does. For the individual developer, this suggests that the ‘coding hero’ whose value was in sheer output speed will be marginalized as organizations prioritize strategic thinkers.

For the industry: The bottleneck is moving from production to curation. When anyone can generate code, the value shifts to knowing what code is worth generating, evaluating whether the generated code actually solves a customer problem, and integrating it into systems that need to be maintained and trusted.

What Developers Can Do (The Honest Version)

Here’s where I want to avoid two equally useless responses. The first is doom: “we’re all going to be replaced, learn to be a plumber.” The second is toxic optimism: “just upskill! Learn prompt engineering! You’ll be fine!”

The uncomfortable truth is that not everyone will navigate this successfully. Some developers will thrive; others will struggle. Pretending otherwise is condescending. But that doesn’t mean the paths forward are invisible. Here’s what I see:

Path 1: Move Up the Abstraction Ladder

Every wave of automation has pushed developers up the stack. We went from machine code to assembly to high-level languages to frameworks to low-code tools. Each transition eliminated some jobs while creating new ones at a higher level of abstraction.

The current shift is the same pattern, just more dramatic. The developers who thrive will be those who move from spewing code to designing systems to framing problems. The question shifts from “how do I implement this?” to “what should we implement?” and “how does this fit into the larger system?”

This isn’t a trivial transition. It requires skills many developers haven’t developed: communication, strategic thinking, the ability to translate business needs into technical architecture. But it’s a learnable shift for those willing to make it.

Path 2: Move Toward the Human Interface

I mean interfacing with humans, not just developing user interfaces. AI is good at generating code. It’s not good at understanding what a frustrated customer actually needs. It can’t read the room in a stakeholder meeting. It doesn’t know which technical decisions will cause political problems in your organization.

The developers who will remain valuable are those who excel at the parts that require human judgment and relationships. Product sense. Client management. Domain expertise. The ability to translate between technical and non-technical worlds. These are skills that complement AI rather than compete with it.

In my previous post, I talked about the “Product Engineer”—the developer whose value comes from customer empathy and system thinking, not syntax-level coding speed. That role is becoming the default, not the exception.

Path 3: Master the New Tools

There’s a genuine skill to working with AI coding tools effectively. Knowing how to prompt them, understanding their limitations, catching their errors, integrating their output into production systems—these are not trivial abilities.

The developers who become exceptionally good at directing AI, who develop an intuition for when to trust the output and when to verify, who can architect systems that make AI assistance most effective—they’ll be valuable precisely because this skill is new and rare.

But I want to be honest: this specific technical knowledge has a shorter shelf. As AI tools improve, the skill of managing them gets easier. This path is a starting point, not a destination.

The Meta-Skill: Learning Velocity

Underlying all three paths is a more fundamental capability: how fast can you learn new things?

The specific technologies that matter today won’t matter in five years. The specific AI tools will be replaced by better ones. What persists is your ability to adapt—to pick up new skills, to abandon obsolete ones without ego, to stay curious when the ground keeps shifting.

This has always been true in tech, but the pace is accelerating. Your learning velocity matters more than any specific technical skill in your current toolkit.

A Different Way to Think About It

Here’s a reframe that might be useful, or might be uncomfortable, depending on your temperament.

The developer identity—the pride in coding skill, the satisfaction in technical mastery—was always partly a social construct created by market scarcity. We were valuable because we could do something rare. We built a culture and a self-image around that scarcity.

The value of that rare skill seems to be diminishing. Which means the identity built on it needs to evolve too.

But here’s the liberating part: if AI handles the typing, what remains is the thinking. The understanding of what problems are worth solving. The judgment about what solutions are worth building. The creativity to imagine things that don’t exist yet.

These were always the interesting parts. The syntax was just the tax we paid to manifest our ideas. If that tax is disappearing, maybe that’s not a loss but a liberation.

Maybe the question isn’t “how do I stay relevant?” but “what can I actually do now that the constraints have changed?” Where there is change, there is opportunity.

Questions Worth Asking Yourself

I’ll end where I usually do—not with answers, but with questions that might be more useful:

• What parts of your work give you genuine satisfaction? Are those the parts AI can replace, or the parts it can’t?
• Are you optimizing for job security or for meaningful work? These might not be the same thing.
• If you could do any kind of work in tech, without worrying about whether you had the right skills yet, what would you choose?
• How much of your resistance or fear of change is about legitimate concerns, and how much is about identity and ego?

The developers who navigate this transition best won’t be the ones who cling hardest to what they know. They’ll be the ones who honestly assess where value is moving and decide—consciously, deliberately—how they want to move with it.

The constraints have changed. The developer’s dilemma isn’t a death sentence for the career, but a forceful, maybe painful invitation to evolution. The most important line of code you write today is the one that reframes your own identity. I’d love to hear your thoughts on what that new identity looks like.