Here’s the plan. I reckon it’ll take about five years in all, and I think we’re about 1.5 to 2 years in already.

Our starting point is that the AI models are now good enough at coding. Not necessarily “perfect”, just “good enough”. Often, they’re as good (better!) than a junior developer. I don’t know about you, but I’m finding the new models pretty impressive. So are other people.

Next, let’s “eat the seed corn”. Junior developers can now be considered (by some) to be superfluous to our needs; for the same cost, we could get soooo many tokens, and get so much more done! Job openings for junior devs will dry up. This is already happening.

One of the interesting things about LLMs is that they love to generate new code. Given their vast corpus of training data, they also know how to write those supporting functions and methods we commonly get from third party libraries. The result? We’ll start writing more and more code. The size of our repos will balloon. This is already happening.

Now, we also know that the tendency of the AIs isn’t to go and clean up code, reduce duplication, or focus on maintainability. Context windows (even the large ones!) can’t hold entire modern repos. They miss things. Most AI written code is additive, and is frequently duplicative. This is already happening.

Machines have a higher “tolerance” for complexity than people, which means we can now bear higher complexity budgets and tech debt. That is, modern AIs tend to be very good at reading code and following the flow of control, often faster and better than people. However, “debugging is twice as hard as writing a program in the first place. So if you’re as clever as you can be when you write it, how will you ever debug it?” still holds true. At some point the tech debt and complexity will be so high even the AIs won’t be able to deal with it. We’ve already frequently blown past human levels of code complexity. This is already happening.

And code is never bug free. Defect rates in AI generated code are typically above that of human-written code, but even if it drops below that, because so much code is being written, the overall number of defects will climb. Because code is seldom properly factored, fixing a bug in one place won’t fix it everywhere. We’ll play whack-a-mole with bugs. This is already happening.

So, we’re going to end up with (we already have!) complex, poorly structured codebases, rife with bugs and duplicated code. Who has the judgment to decide what to delete, which abstraction is wrong, or whether the whole approach needs rethinking? Who do we call in to fix this kind of mess?

Senior developers.

However, there’s attrition in the industry. Senior developers leave, not only because of the regular attrition that occurs over time, but also driven by a 22% spike in critical burnout as they are forced to manage the massive influx of AI-generated complexity. Because we’ve stopped hiring juniors, there are few new seniors coming up to replace them. The ones who do make it through haven’t experienced life before AI; they’ll be good, but they won’t necessarily be great at writing maintainable code. In a market where senior, production-ready engineers are already the primary bottleneck, I think we’ll need seasoned developers with good taste more than ever.

In any market where there’s increased demand and reduced supply, prices go up. This happened for the COBOL programmers of yore during and shortly after Y2K. It’ll happen for senior developers soon, and just like our COBOL-wielding brethren before us, there will a shining window of opportunity. We just need to hunker down and survive the storm of AI-driven layoffs.

Then, my friends, we’re going to make out like bandits.