The developer profession in 2035: What disappears, what endures

The prediction that is always wrong, and always a little right

The death of the developer has been forecast at regular intervals for seventy years.

Compilers were going to make programmers redundant: IBM’s first FORTRAN report, dated November 10, 1954, promised the system “should virtually eliminate coding and debugging”. Who needs people who write machine code? Fourth-generation languages would let business people build the systems themselves. Low-code would democratize everything. Offshoring would empty the offices.

Each time, the forecast got the conclusion wrong and something else right: the content of the job changed. The assembly programmer all but vanished. The profession endured, but it carried different work.

So when the same forecast comes around again, with more force than ever, the right question is not “are developers going away?” It is:

Which work carries the profession in 2035, and which of us is trained for it?

Let’s sort it. Honestly. Into three piles: what disappears, what endures, and what gains value.

Pile 1: What disappears

Large parts of what fills a developer’s day today are on their way out:

The translation work. The core of much development has been translation: from need to specification, from specification to code, from one language to another, from one framework to the next. Translation is among the things the models do best, and every year the line moves – a translation can be larger and more complex before it needs a human.

The re-creation work. A startling share of all the code being written is a variant of code written before: CRUD, integrations, forms, mapping. On our team AI writes around 80% of the code, one way or another, and almost all of it is re-creation. The share is growing.

And the lookup value. Knowing the syntax, the APIs, the patterns – the knowledge that once separated a senior from a junior – has become free. Not unimportant. Free. That is a different thing, and the difference reshapes the whole value chain in knowledge work.

The grief over this pile is real and deserves respect: many of us liked this work. It was where the flow lived. But nostalgia is not a strategy.

Pile 2: What endures

Now to the part the forecasts always miss, because they confuse coding with development:

Responsibility endures. Someone has to vouch for a system doing what it should, not doing what it shouldn’t, and being changeable when the world changes. Models produce; they do not guarantee. Responsibility requires someone who can be blamed, learned from and trusted. That is by definition a person. The whole security responsibility, the whole quality responsibility, the whole “this is what we stand behind”: none of it moves to a model. It concentrates in fewer people with longer reach.

Context endures. Every system lives inside a reality the models never see: the business, the history, the compromises, the people and the scars. Knowing that reality – and translating between it and the technology – has always been the underrated half of the job. That half cannot be automated, because the reality is not written down anywhere. (And where it is written down, it is because somebody did the work: the TDRs, the context files (in Norwegian) are human work too.)

And judgment endures. Choosing between ten solutions that all work. Knowing which complexity is worth its price. Recognizing the proposal that is plausible and wrong. All of this has become more of the job, not less – because the problem is no longer a shortage of answers, but the volume of them.

Pile 3: What gains value

And then the interesting one, the skills that rise because the rest falls:

Assessment at scale. When production is free, assessment is the bottleneck, and whoever can assess quickly, correctly and in a way others learn from is worth more every year. Review skill, an architectural eye, the ability to see that something does not belong: that is the 2035 craft.

The art of specification. Expressing intent precisely enough that it can be built – by people or by machines – becomes a core skill, perhaps the new core skill. It gets a text of its own, because it deserves one.

Depth of system understanding. When fewer and fewer people actually read the code, the ones who can go all the way down – who understand the whole stack when the abstractions leak – become rare and indispensable. Deep understanding was always valuable. Now it is getting scarce.

And the relational work. Everything this series has been about since The Quiet Responsibility: direction, trust, ownership, holding a system – and a team – together. It was never a side effect of the job. In 2035 it is clearer than ever that it was the core.

What you do about it today

Three pieces of advice, one per career stage:

If you are a junior: don’t compete with the model over pile 1. You lose, and it is not where you should be building yourself up anyway. Spend the freed-up time on what endures: understand systems deeply, train your judgment, learn to assess. The road is longer without the translation work as a training ground – that is a real problem, and it has a text of its own – but the road exists.

If you are a senior: audit your pride. If your identity lives in pile 1 – in the speed, the syntax, the output – it is time to move it, deliberately, over to pile 3. You already have the skills; it is the weighting that has to change.

If you are a lead: your team is going through this sorting whether you lead it or not. Lead it. Say out loud what is about to be valuable. Build the practices that train pile 3. And be honest about pile 1. False comfort is not care.

Seventy years of forecasts

The developer profession in 2035 will not resemble 2025. Nor did 2025 resemble 2015, or 2005. We simply forget how much it has already changed, because the changes arrived slowly enough to feel like growth.

This one arrives faster. But the direction is the same as it always was:

Away from translation. Toward responsibility, context and judgment.

The profession endures. The only question is the one it has always been:

Does your version of it endure?