"a single staff engineer with experience and a trusty LLM is similarly productive as a team of 2-4 junior engineers"

I think we are SEVERELY underestimating the amount of slop that is going to come from this.

Same as it did it 10 years ago.

Generalists will be undervalued, but will always be able to find a job.

There will be pockets of extraordinary cruelty and pockets of extraordinary grace.

Where you find yourself on the cruelty/grace/specialist/generalist surface will still be up to you, but also, just as it has been for thousands of years, also up to fate.

Do your best, control the things you can, and accept the things you can't. Remember that work is just work, not living.

Hang in there, it's only 10 years more to get there...

I think there will be a crash of any sort of junior positions and the employment numbers will fall down. There will be need for experienced, intelligent developers, but only highly below average.

Average devs will be no longer needed as all they can do a senior will be able to do in the same time with LLM.

I think we'll go back to the system as in the Mythical Man-Month - one lead developer, one below them to do less important tasks, and a few domain experts not related to programming. Ironically I think good front-end developers may remain useful as UI/UX experts.

It's difficult to imagine what it will be like, but it will be radically different. There will always be a need for a programmer to be able to review code and make sure things are going in the "right" direction. One can speculate if this one human + AI will replace 10, 100, or 1,000 human workers.

Recently, there was an analysis of when we might get to Post-Labor Economics:

> 2025 to 2030: Collapse of knowledge work. The "KVM Rule" applies: any job you can do entirely with a keyboard, video, and mouse will be fully replaced.

https://x.com/daveshapi/status/1916188978727784847?t=9YNl90V...

The idea that you could just learn python and make an upper 5% salary in the first place was absolutely wild in the first place. I've been screaming at anyone who would listen for the last 2 decades that programming is a skilled trade and it's practitioners should be unionizing. This is more true than it ever was. It won't happen, the HN cadre will continue to turn up its nose at the idea until they are slowly incinerated by the roaring flame of capital exploitation.

In 10 years, I suspect we will have more off-shoring, extremely few entry/mid jobs on-shore, and an increasing push towards being tech lead like guides. I think companies will use off-shore labor and LLMs to do most of the grunt work while we have senior+ engineers focused on guiding those people/agents.

It's just one more step in the multi-generational trend of eliminating/outsourcing lower skilled jobs and increasing the barriers to entry for the remaining jobs. I'm not optimistic.

10 years is a long time.

Enough time for LLMs to see marked improvement and possibly the hallucination issue to be significantly reduced or solved.

When then happens the remaining software engineers won’t be skilled. Like many people in the principle or staff position or managerial position… technical skills don’t matter. AI now handles technical skills and the people controlling the AI are people who can navigate the politics.

I know you’re trying to see where the puck is headed but I think there is a lot of work between where we are and where LLMs replace 4 Junior devs.

The workflows we have are not quite right for it. Coding has always been 10% coding and 90% debugging but I think the rate at which we generate the 10% will grow exponentially.

This means that the debugging has to grow. We will generate errors at an unprecedented rate.

LLMs trained on previous errors and methods won’t catch them. They’ll be more complicated and spread out over the code.

We need new tools to visualize the code and track errors. I think what it means to be a programmer will change. More testing, thinking and less klocs.

For tech writers, it'll mean becoming editors more than writers. Editors of LLM generated stuff. For developers, I guess the evolution will be similar: more architectural thinking, more code reviews, less typing boilerplate.

10 years is just too far out to talk intelligently about? I’d start with three years.

no clue

Tech employment in 10 years is going to favor candidates who know how to get the job done with the fewest moving pieces.

The current era of making the most complicated fucking thing possible is clearly nearing its conclusion. The writing is on the wall with the now weekly conversations about vendor and dependency management crises.

One might say to use something with more batteries included or whatever. I'd go 5 steps further - have you solved the problem outside the computer yet? Do you understand the domain model? Do you understand why the customer wants to pay for any of this bullshit in the first place?

I think that's approximately what it's going to look like. Excel, bash and powershell replacing kubernetes clusters.

There's a lot of hope in the other comments that senior engineers will survive. And who knows, maybe something will occur to slow AI development. Or maybe we'll hit some hard limit we can't anticipate. Maybe society will even lurch left and act to protect jobs. But if none of these things happen, there will be a day when senior engineers find themselves unemployable, like pretty much every other worker.

I think over the next decade many countries are going to flex their autonomy and replace "Big Tech" with their own tech so there will certainly be opportunity in the EU, in UK/AU/NZ/CA, in Latin America. The whole supply chain from embedded software to drivers and operating systems and user-facing software and platforms is going to be under more scrutiny than ever.

One thing that is constant is the billions of people using the internet and their buying power, so I think there will also be tremendous opportunity for people able to release good software while mid+large+huge tech companies focus on eliminating the expensive tech salaries that built and sustain their fortunes. Their software is going to become shittier until LLMs get much better.

The day to day of a software engineering job has changed and will change more depending on how advanced llms get (and all bets are off if we do get to AGI). However, I don't really think you will see a massive drop-off in employment for two reasons. First, competition is going away. If your developers are x times more productive, so are your competitors developers. I can see a bit less need in non-product companies if more domain experts are able to build their own tools, or generalized agentic tools eliminate some of the need for custom tooling.

However, I think there is a second thing that is often overlooked here. It seems the angle is always 'oh companies can replace developers' but no one seems to consider that developers can replace companies. I think you are going to see small teams of very skilled people replace able to make amazing products. There are limits to what llm's can do on their own but a skilled engineer who masters the tooling and can unblock the models and knows the techniques to keep the models productive as the codebase grows will be able to produce amazing things far beyond what they could ever produce before. I think you are going to see an explosion of new, smaller companies. I think if you are an engineer you shouldn't be gloomy, you should be excited.

Everyone is talking about AI this and AI that. I think the more pressing job market pressure is from there being way too many graduates due to increased interest in the field from the general population. I TA at a university and I see the current crop of CS students and the demographics have changed a lot.

I think we’ll see a lot more software. Lots of non tech people will increasingly have the ability to create custom software tools and prototypes. They’ll share and remix these. Some of them will be fully productized, at which point professional software engineers will be called in to help untangle the LLM spaghetti and create proper applications. So I think there will be more software work in consultancy.

I think we’ll see advancements in robotics and more hires there.

And I think there will be more jobs around the LLM ecosystem — progress on foundational models, inference optimizations, on prem migrations, networks of agents, AI more deeply integrated with existing sw.

Overall I think there will be more jobs in observability, security, and infrastructure.

I agree there will be fewer junior positions. I’ve written about some of these ideas before including a deskilling for new practitioners https://matthewbilyeu.com/blog/2025-03-08/ai

I’ve been working with a team of so called ‘junior’ devs and coding is the least of the problems. Design and architecture is by far the most difficult thing for people to understand and get a hang of. A staff engineer won’t replace 2-4 junior devs with LLM. He will focus on the design and architecture and then get 2-4 engineers to execute it with LLMs. The two might sound the same but it’s not. And that’s the difference between understanding software engineering and coding. LLMs make coding easier, not software engineering.

In 10 years, resource, energy limits, and wealth inequality will become increasingly clear to everyone, while the climate continues to warm at an accelerated rate. Social instability might preclude the existence of software engineering, aside from a tiny minority supporting the lavish lifestyles of the ultra-wealthy.

The pattern you've said makes sense. The amount of full stack engineering roles will reduce with LLMs and agents able to complete these tasks with the required context.

Computer Engineering domain will continue to grow. This will be due to 1) need for better GPUs and CPUs 2) need for data centre infrastructure engineers

LLM ecosystem will also continue to grow along with Machine learning ecosystem. Regression based models cannot be replaced by LLMs due to inherently not being reliable in producing consistent output for structured problems

No one knows or even has the slightest idea. Predicting the future is a fool’s errand.

How did manufacturing adjust to the rise of 3d printing and the new world where 90% of consumer goods were printed at home, replicator-style?

How did the finance world adjust to a world where financial transactions were automated on the blockchain using smart contracts?

How have cities adapted to the massive migration of in-person experiences to the metaverse — and so soon after they rebuilt all their physical infrastructure around the revolutionary personal transportation system known as the Segway[0]?

[0] none other than Steve Jobs predicted that cities would be designed around the Segway https://www.theguardian.com/world/2001/dec/04/engineering.hi...

I can't say anything on how work will be organised, but there's a thought I had the other day:

The rate of adoption of new APIs will slow down considerably.

LLMs only really know what they're taught and when a new API comes out, the body of learning material is necessarily small. People relying on LLMs to do their jobs will be hesitant to code new things by hand when a LLM can do the same using older APIs much faster.

Who is going to do it then? Well, someone has to or else the API in question won't see widespread adoption.

Try this experiment. Install a few apps, like Time Doctor and Wakatime to track where you spend most of your time while on the computer for work purposes.

After a week, take note of how many hours you spend actually writing code.

I won’t share my exact count, but it’s shockingly low in relation to all of the hours spent working.

My bottleneck to more productive output is 100% not “unable to write more code faster”. It’s actually people. Other people.

Expert in debugging AI coding crap, I guess... People that still really understand code...

It will be glorious! LLMs Will replace most managers and all executives. Developers will use their corporate AI to answer all questions from the outside world, allowing them to focus entirely on writing code. No need to talk to other humans, aside from other developers. Coders will develop lasting personal relationships with their IDEs. AI enhanced design tools will provide pixel perfect designs that users always love. Glorious.

Gen Z and the generation afterwards, having had parts of their psychology destroyed by Tik Tok, ready access to AI for cheating school and such, will lack the attention span to properly learn time intensive skills such as coding and first principles engineering. Knowledge of complex maths and theorems will be lost and there will be generally no interest in things such as functional programming, proofs, math, etc.

Initially there will be a huge employment downturn as organisations follow the pattern of hiring a Gen Y expert and supplementing them with Gen Z juniors using increasingly good AIs.

After a while, the Gen Y seniors will retire and/or die and it will be impossible to source a senior developer with actual knowledge. Wages will skyrocket for a few Gen Z experts, but in general there will be a shortage and the entire industry will eventually reboot, although I am stuck to speculate how exactly.

At some point, we will lose the ability to quickly make advancement in AI because engineers will stop understanding how they work due to a lack of deep understanding in mathematics etc. and advancement will drop by 100x or 1000x.

Due to people becoming very lazy on average, capitalism will become ineffective and most governments will veer towards centralised services, or central planning/communism to cope with the lazy populous. A few people with work ethic approximate to today’s founder work ethic, or deep skills, will be worshipped.

We're on the cusp of an indie software boom.

The reasons why exist in Taleb's antifragility thesis: the antifragile will gain from disorder.

The nature of the tech industry, in the decades roughly since the Cold War ended(which put to rest a certain pattern of tech focused on the MIC and moved SV forward into its leadership position), has promoted fragility along several of Taleb's dimensions: it aims to scale, it aims to centralize, and it aims to intervene. The pinnacle achievement of this trend is probably the iPhone, a convergent do-everything device that promises to change your life.

But it's axiomatic(in Taleb's view, which I will defer to since his arguments are good enough for me) that this won't last, and with talk of "the end of the US empire", and a broader pessimism in tech, there seems to be popular agreement that we are done with the scale narrative. AI is a last holdout for that narrative since it justifies further semiconductor investment, stokes national security fears of an "AI race" and so on - it appeals to forces with big pocketbooks, that are also big in scale, and also in a position of fragility themselves. But eventually they will tap out too, for the same reasons. Whether that's a "next year" thing or a "twenty years" thing is hard to predict - the fall of the USSR was similarly hard to predict.

The things that are antifragile within software are too abstract to intentionally develop within a codebase, and are more a measure of philosophy and how one models the world with data - CollapseOS is at the extreme end of this, where the viewpoint is bacterial - "all our computing infrastructure is doomed if it is not maintainable by solo operators" - but there are intermediate points along it where the kinds of software that are needed are in that realm of a plugin to a large app or an extension to an existing framework, and development intentionally aims not to break outside that scope. That thesis agrees with the "small niches" view of things.

Since we have succeeded in putting computers into every place we can think of, many of the things we need to do with them do already have a conventional "way of doing it," but can exist in a standard and don't need to be formalized behind a platform and business model - and LLM stuff does actually have some role in serving that by being an 80% translator of intent, while a technical specialist has work in adding finish and polish. And that side of things agrees with going deeper into the stack.

I believe one pressing issue that's faced with this transition is the inclination brought from the corporate dev environment to create a generalized admixture of higher and lower level coding - to do everything as a JS app with WASM bits that are "rewritten in Rust" - when what indie software needs is more Turbo Pascals, Hypercards, and Visual Basics, environments that are tuned to be complete within themselves and towards the kinds of apps being written, while being "compatible enough" to deploy to a variety of end-user systems.