Should we programmers fear being automated by AI? This question has gained significant traction as Large Language Models (LLMs) continue to demonstrate increasingly impressive coding capabilities. In this post, I’ll focus specifically on whether senior level programmers should fear becoming obsolete. The meaning of senior has been very elastic over time, but for the purpose of this blog post, I define it as those with 5+ years of experience who have demonstrated good competence and output compared to their peers. I’m deliberately setting aside the impact on junior positions for now, though I’ll touch on that briefly at the end.
My conclusion? If you’re a senior developer, you should not fear being out of a job indefinitely, but you should probably plan to have savings that could last you two to three years — just in case. As with any prediction, the future is a fickle beast and no one truly knows anything, myself included. This is simply how I’m thinking about my own career and financial planning.
(Truth be told, I’m not quite at this senior level yet, but at the time even a single programming job is in danger of being automated, and I suspect I will be..)
To analyze this issue, let’s consider two key dimensions of AI progress: competency and efficiency. Competency refers to which programming tasks AI can theoretically solve, while efficiency encompasses the resources required to perform these tasks — particularly energy consumption. Historically, the cost per LLM query has followed a predictable pattern: quickly declining but fixed for each interaction. In just two years, OpenAI’s query pricing has dropped at least 53x¹, but throwing more money at a query wouldn’t necessarily improve the result.
That has changed with search-augmented models such as OpenAI’s o1 and o3 and DeepSeek’s R1. As long as you give them more compute, they will perform better (although logarithmically).
This means that even in a future where AI can theoretically handle every senior developer task if it requires 50MW of power to do so, our jobs remain safe — after all, even well-paid Silicon Valley engineers don’t command thousands USD per hour in salary.
I’m partitioning our future into a small set of scenarios, and in each I will argue we need not worry about being out of jobs.
The Competency Plateau Scenario
Imagine a world where AI models don’t advance much beyond their current state. In this case, most programming tasks would still require human expertise, making job security a non-issue.
The Energy-Constrained Scenario
Consider a future where AI achieves senior-level programming capabilities but remains extremely energy-intensive. As noted earlier, a senior AI engineer which consumes thousands of dollars in electricity per hour isn’t economically viable, regardless of its technical capabilities. But let’s explore this scenario more rigorously.
What’s the energy efficiency threshold for AI to displace human engineers? Let’s run the numbers:
- Assume a going rate of $100/hour in salary (this might be conservative for Silicon Valley)
- Electricity cost at ~10 cents/kWh
- Energy comprises roughly half of the total operational cost
This equates ~500kW of energy as the threshold for when it is economically viable to completely replace a senior engineer. But is this realistic at scale?
Let’s examine the broader energy constraints:
- In 2023, the US generated around 475GW of electricity.
- Assuming a generous 20% increase in the near future: 600GW.
- Realistically, perhaps 10% could be allocated to automated software engineering: 60GW
- There are roughly 4.4 million software engineers in the US
- I’m guesstimating around 25% meet our “senior” criteria: 1.1 million engineers
- Average US working hours: 1,892 per year² (about 20% of total hours compared to working literally 24/7)
- Equivalent to 240,000 24/7 AI engineers
With these figures, completely automating all US senior software engineers within a 60GW energy budget requires each AI engineer to operate at 250kW or less. For economic viability, we likely need to see energy usage in the low hundreds of kilowatts, possibly below 100kW per AI engineer. These requirements would be even stricter outside the US, where engineering salaries are typically lower.
Is it probable that even though the top-level competency of AI models gets to a senior level, the energy usage plateaus at a too high level, e.g. a few MWs? The recent history of machine learning is that energy usage as a function of model competency drops like a stone over time³. Enabling energy efficiency of an engineering model would be one of the greatest economic opportunities of the century, and if it is even remotely feasible to achieve, the combined effort of the world’s AI labs will certainly find it.
Our own brains are an existence proof you can have remarkable competency using only ~20W. We could be thousands of times less efficient than nature’s solution and still achieve our target of 100kW per AI engineer. Moreover, we did not evolve to code, but to survive a complex physical and social environment. Models built with coding abilities in mind may be on an efficiency curve going far below our brain’s energy usage.
My assessment? If we demonstrate that senior-level AI engineering is technically possible, achieving economically viable energy efficiency will follow. While this scenario provides job security in theory, I don’t find it particularly likely in practice.
The Full Automation Scenario
If AI achieves both high competency and low energy consumption, the end of programming jobs becomes inevitable. In this scenario, AI won’t just excel at coding — it will master system architecture, project planning, issue triage, team communication, and coordination. While I won’t speculate on the probability of this outcome, its implications make job security concerns essentially moot.
Here’s why: I believe there is enough competency overlap between a skilled senior-level programmer and an AI researcher, that once such a programmer can thoroughly be automated, so can most of AI research. Automating AI research is essentially the end game. That opens up the floodgates of self-improving AI and then an intelligence explosion. The speed of this intelligence explosion is a hotly contested subject among speculators in the space, but I think a few years is enough to so thoroughly change society not much will be left recognizable to our contemporary eyes.
Certainly, this means there will be no jobs left for us poor programmers, but that concern is also utterly inconsequential in the big picture. Imagine we could see a giant asteroid on the horizon about to hit the Earth, and you are concerned you don’t know how to keep the dust from the explosion out of your eyes. Frankly, it does not matter one bit as the asteroid will bring cosmically larger fish to fry. The analogy isn’t perfect as an asteroid hurling towards the Earth is purely a calamity whereas an intelligence explosion may be a calamity or it may be the best thing to have ever happened. Staying in the analogy, our AI asteroid is more of a weird stochastic variety either bringing doom or paradise. In any case, worrying about dust in your eyes seems less than pointless.
In essence, in the scenario where we (programmers) get completely automated away, I worry not about my job since either destruction or paradise awaits just behind the horizon.
However, there might come a few years between when I lose my job and the intelligence explosion really sets into gear, and during this time I better have some savings I can live off of lest I want to forego my comfortable lifestyle.
The Partial Automation Scenario
What happens if AI can handle a significant portion — but not all — of a senior engineer’s responsibilities? This might result in the need for fewer programmers and put downward pressure on our salaries. This scenario certainly does not mean a life of destitute, but perhaps results in a 30–40% reduction in salaries due to an oversupply of labor. I don’t find this particularly probable either, but the analysis is slightly more complicated.
The first question to ponder is which specific fraction of a senior-level programmer’s job would be automated away and which would be left behind. I suspect a lot of the strictly programming-related tasks are going to go away. Essentially, the work a senior level could find themselves off-load to a very junior engineer. In my experience, there is a wide distribution in how much hands-dirty programming a senior is doing. Some only do very little (<20% of their working hours) and others far more (>50%). With good (but not incredible) automation, I envision many seniors will be pushed into the ~20% category, leaving the rest of the job to be architecture design, planning meetings, triaging, coordination, discussions, etc.
But not all code would be left to the machines in this scenario. I have seen the following situation many times: A senior develops a high-level design for solving a problem, creates the foundational architecture, establishes extensible APIs, and implements about 20–25% of the core functionality.
At this point, they then hand off the remaining implementation to junior engineers in an ongoing collaborative effort with code reviews, technical discussions, and mentorship.
In this scenario of model competency, I imagine such foundational skeleton work is still mostly done ‘by hand’, albeit with help from some next-gen CodePilot lookalike. The grunt work of implementing all the functionality will be largely done by AI models, and instead of spending time on mentorship and technical discussions with juniors, the senior would spend more time code-reviewing the generated code. As you can (for the most part) review code much quicker than you can write it, this will speed up development significantly.
My educated guess? This might lead to a roughly 3x increase in development speed. The bottleneck would never be grunt implementation of functionality (as it sometimes can be today), but code reviewing and the less programming-oriented tasks of a senior. The question remains how this could potentially affect the job market and salaries. If we take for granted the 3x increase in development speed, a surface-level consideration would determine we would need one-third the current amount of skilled programmers. This would most surely put a dent in salaries! But as we know, when productivity increases, consumption of a, now cheaper good, has a tendency to just increase accordingly (see Jevon’s Paradox).
At this point, I could reference quantitative data showing the increase in lines of code committed to GitHub or the sizes of known, large projects over time. This could paint an argument that society (for whatever reason) only craves more, not less, software to an ever-increasing degree. However, such quantitative graphs I think would betray an illusion of mathematical certainty of the future that I don’t think truly exists to support my main point. Instead, I’ll leave you with a vibes-based analysis: In a potential future where skilled programmers are 3x as productive, would Silicon Valley opt to only produce its current amount of software and products, or would they simply at least 3x the amount of (more or less useful) products and complexity?
In this hypothetical, surely the AI companies supplying such powerful code-generating models would see massive revenue gains, and the AI hype train would bring with it massive amounts of capital just dying to be spent on… well at least something! This is exactly the mentality we are witnessing now (and have witnessed for decades in this decadent industry). What self-respecting investment fund would be content with burning money on just the amount of output being produced today when a 3x increase lies on the table which is up for grabs?
In short, in this scenario, I would not worry about neither jobs nor salaries for skilled programmers.
Conclusion
In no scenario do I worry about jobs for senior programmers. Either because they remain un-automateable, economically unviable to do so or we bring forth the AI overlords making the entire thing moot. The only advice I have is to make sure you can go without a job for a couple of years as we (potentially) transition from the world of today to the world of superintelligence and technological singularity. If you want to plan for this, you should probably make your investments at least somewhat correlated to the AI industry to further boost your savings should you be automated away. Whether that for you means dumping it all into NVIDIA call options or prudently sticking to a global index fund, I really cannot say. In any case, even if AI never takes our jobs, it has never been a bad idea to save and invest.
What about junior engineers?
This piece has almost exclusively been concerned with senior-level engineers. What about the prospects of quite junior ones? If we have complete programmer automation, clearly juniors and seniors are in the same position. But one of my scenarios, The Partial Automation Scenario, could turn out difficult for people with only a little experience. Given that level of automation, the competency required to be economically productive would probably be somewhat higher than today. A 6 month React bootcamp ain’t gonna get you anywhere then (I’m not sure it will get you far today either though..).
One outcome could simply be that it requires a couple more years of education to be taken seriously as a candidate. In this case, you will still end up getting a job, but just with some more student debt to live with.
One other possibility is that your first few years of programming will resemble more that of an actor’s career. You probably won’t get a programming job easily but instead, get by e.g. by waitering while in your spare time, you work hard on hobby projects. After a couple of years of this, you will have gained enough practical experience and have a portfolio worth showing off after which companies will start taking you seriously.
This would obviously be a big step backward in terms of the job market of today, but a job market will still exist for you if you persevere. The last possibility I’ll consider is that you are fresh out of uni just in time for junior programming jobs to have evaporated. As you spend the next couple of years trying to gain experience through hobby projects, AI unfortunately progresses faster than you, and you keep being behind until the technological singularity swallows us all. In this case, I hope you have parents with a bit of money to support you as we wait for our AI overlords to come. If not, good luck until then.
Footnotes
1: Back in November 2022, OpenAI’s most capable model, Davinci, cost $0.02/1k tokens (https://web.archive.org/web/20221130060640/https://openai.com/api/pricing/).
Today, OpenAI’s GPT-4o mini cost $0.000375/1k tokens (https://openai.com/api/pricing/) (assuming an even input/output split), or 53x reduction. And very importantly, GPT-4o mini is much, much more capable than their old Davinci.