Part one of a three-part series on agentic coding and what it means for the profession.
About a year ago I gave a talk internally about disruption in our industry. Not the kind of disruption that gets breathlessly announced at every conference. Real disruption. The kind that doesn't just create new opportunities, but materially eclipses the ones that existed before.
I made a distinction that I think is important, and one I want to make here: not every major technology shift is a sea change. Some shifts expand the market. Some shifts replace it. Those are very different things. And right now, we are in the early stages of the second kind. The difference this time is that I think the replacement goes further than it has before.
Let me explain what I mean.
Two Shifts That Actually Changed Everything
The first one was personal computers.
The IBM PC launched in 1981. At that point, if you were a professional developer, you almost certainly worked on mainframes or minicomputers. That was the industry. Not a part of it. The whole thing, by any practical measure.
By 1984, desktop computer sales exceeded mainframe sales for the first time. By the early 1990s, IBM, a company whose entire identity was built around mainframe dominance, was posting losses in the billions as corporate spending shifted to microprocessor-based systems. Within roughly a decade, the center of gravity of our entire profession had moved.
I made that transition. I watched what happened to the people who didn't move. A lot of them were talented. Experienced. Deeply skilled in their domain. But they were holding expertise in a context that was rapidly becoming a niche while they'd spent their careers treating it as the whole landscape.
The second shift was the web. Not the internet. The web.
Mosaic browser launched in 1993. By 1995, Amazon, Yahoo, eBay, and Craigslist existed. By 1998, Google launched. The transition from "most professional developers have never written a line of web code" to "most professional developers are primarily web developers" took roughly five years.
Five years. Not a generation. Not a decade. Half a decade.
I made that transition too. Deliberately. Not because anyone told me to, not because my employer had a plan for my reskilling, but because I looked at where things were heading and decided I was going to be ahead of it rather than behind it. The people I watched struggle through both transitions, and there were many, mostly had one thing in common: they waited. They waited for certainty, for someone to tell them it was time, for their organization to guide them through it. By the time they got moving, the window for a comfortable transition had already closed.
What Doesn't Count
Mobile doesn't belong on this list, and I want to be careful about that because it's a common counterargument.
The iPhone launched in 2007. The App Store launched in 2008. Native mobile development created new opportunities and a new category of specialization. But it didn't eclipse what was there before. I know plenty of excellent developers who've never shipped a native mobile app and whose careers have suffered not at all for it. Mobile expanded the market. It didn't replace it.
That distinction matters because it defines what we're actually talking about. A sea change isn't "a new platform shows up and some people build for it." A sea change is "the primary platform shifts, and if you don't move with it, you're no longer working in the mainstream of the profession."
By that definition, the web was a sea change. Mobile was not.
The Pattern, and the Acceleration
Here's what I want you to notice.
The PC shift took roughly a decade. The web shift took roughly five years. Both followed a similar arc: a new capability emerges, early adopters look like hobbyists or enthusiasts, a tipping point hits, and suddenly the mainstream has moved. What was core expertise yesterday is a legacy specialization today.
The cycle isn't just repeating. It's accelerating. Both in the time between major shifts and in the speed at which each shift goes from nascent to dominant.
Which brings us to now.
Agentic Coding Is the Third One
I gave that talk a year ago about AI specifically because I recognized the arc. I've lived through two of these. I know what they feel like at the beginning, when the early adopters are excited and the skeptics are comfortable dismissing it as hype.
This one is not hype.
Agentic coding, AI systems that don't just assist with code but actively write, refactor, test, and reason about it, is following the same pattern. The difference is the speed. I don't think we have five years before agentic coding becomes the mainstream context in which professional software development happens. I think we're talking about two or three. Possibly less.
If that sounds alarmist, I'd ask you to consider how it would have sounded in 1983 to tell a mainframe developer they had about eight years before their core expertise became a niche. Or in 1994 to tell a desktop developer they had about four years. Both of those statements would have seemed extreme at the time. Both were accurate.
Here Is Where This One Is Different
I want to be honest about something, and it's the part of this I've wrestled with most.
The PC and web transitions didn't reduce the number of developers. They changed the landscape and ultimately expanded the profession dramatically. More platforms meant more software meant more demand for people to build it. The disruption was real, but the overall trajectory was growth.
I don't think this transition works that way.
Agentic coding doesn't just change what developers do. It changes how many developers are needed to do it. One developer working with agents can do what previously required a team. That's not an expansion of the market. That's a compression of it.
The transition from mainframe to PC required developers to reskill. The transition from desktop to web required developers to reskill. This transition will require something more fundamental: it will require a portion of people who currently call themselves developers to recognize that what they've been providing, the ability to translate requirements into working code efficiently, is being automated. Not assisted. Automated.
I'm not saying there will be no developers. I'm saying the profession will contract around the parts that aren't automatable, and expand around the parts that are newly possible with agents doing the implementation work. The developers who thrive will be the ones who were always primarily problem solvers and happen to have used code as their medium. The ones who are primarily builders, who find their satisfaction and derive their value from the craft of implementation itself, are facing a much harder road. My colleague Justin Searls has a phrase for this: if the clackety-clack of the keyboard is your primary means of delivering value, that's a precarious place to be right now.
That's a tough thing to say. But I'd rather say it plainly than let people make career decisions based on a rosier picture than the evidence supports.
Nobody Is Going to Manage Your Transition For You
Here's what I observed across both prior transitions, and in myself.
The people who came through well didn't wait for permission. They didn't wait for their employer to build a reskilling program. They didn't wait until the shift was undeniable before starting to move. They looked at the direction of things, made a judgment call about where the profession was heading, and started investing in that direction before they were forced to.
I did that. Twice. Not because I'm especially prescient, but because I'd developed a habit of looking at where things were going rather than where they were. The mainframe-to-PC transition taught me that the time to move is when it still feels optional. By the time it feels necessary, the most valuable positions are already taken by the people who moved early.
The same is true now. The developers who will be best positioned in three years are the ones who started genuinely engaging with agentic coding today. Not using it as a fancy autocomplete. Actually engaging with it, letting go of implementation as the primary measure of their contribution, developing fluency in a new kind of collaboration between human judgment and machine capability.
Nobody is going to do that for you. Your employer might support it. Your team might create space for it. But the decision to move, the recognition that this is a transition you need to make rather than a trend you can wait out, that one is personal. It always has been.
What to Actually Do With This
The skills worth investing in are not the ones that agents will be able to do better than humans in three years. They're the skills that complement what agents can do.
Problem definition. Knowing what you're actually trying to solve before you start building. Outcome clarity. Being able to say, with precision, what "done" looks like and how you'll know if it's working. System-level judgment. Understanding how pieces fit together and where things are likely to go wrong, even when you haven't read every line of code. The human accountability layer that agents fundamentally cannot provide.
Interestingly, those are the skills that have always separated the best developers from everyone else. The market has underpriced them for years because raw implementation capacity was the scarcer resource. That is changing fast.
If your honest self-assessment is that your value has been primarily in writing code efficiently, that's not a comfortable place to be right now. But it's important information. The transition is more manageable if you start now than if you wait until the market makes it unmistakable.
We've been here before. Twice. The pattern is recognizable. The people who did best weren't the ones with the most to lose. They were the ones who looked at what was actually happening and decided to move with it rather than stay put or try to escape it.
You don't survive a riptide by treading water or swimming harder toward shore. You survive it by understanding the current and moving with it. The people who drown are the ones who trust their fear and choose to resist.
That decision is yours to make. It's also yours to make soon.
I'm already swimming, trying to find the current. I hope you'll join me.