There is a story being sold right now that I think is dead wrong.
The story goes like this: AI writes code, code is what engineers do, therefore engineers are finished and the firms that employ them are next. Dario Amodei, the CEO of Anthropic, said AI would be writing essentially all code within twelve months. Mark Zuckerberg told Joe Rogan that Meta is building AI to replace mid-level engineers. The headlines have done the rest, and a lot of smart people now believe software engineering is a sunset industry.
I sit on the other side of this trade. I am a Director of a software engineering firm, and I run our Family Trust on the thesis that technology is about to consume the world exponentially rather than linearly. When I look at the data, I do not see a shrinking profession. I see one of the great expansions of demand in the history of the industry. Let me show you why.
Start with the number that everyone is reading backwards
In April 2026, GitHub was absorbing roughly 275 million commits a week, putting it on pace for around 14 billion for the year. That is about a 14x increase over 2025, when the platform was running near 90 million commits a month. The curve did not bend. It went vertical.
Almost everyone reads that number as a death notice for engineers. The machines are writing the code now, look at the volume, the humans are done.
Read it again. Code is the cheap part now. It always was the cheap part. What has just happened is that the world is producing fourteen times more software, and every single unit of that output still has to be planned, reviewed, integrated, secured, and owned by someone who is accountable when it breaks. You do not ship 14x the code with the same number of people thinking about it. You ship it with more.
The volume going vertical is not evidence that humans are leaving. It is evidence that the surface area of software a human has to oversee just exploded.
This is Jevons’ Paradox, and it has happened before
In 1865, the economist William Stanley Jevons noticed something strange. As steam engines became more efficient and coal-per-unit-of-work fell, England did not burn less coal. It burned dramatically more. When you make a resource cheaper to use, you do not reduce consumption. You unleash it, because demand was being held back by cost the whole time. This is Jevons’ Paradox, and the AI world has rediscovered it.
Software has been sitting on the largest backlog of unbuilt demand of any industry on earth. Every business I have ever worked with has a list of things they would build if it were cheaper and faster. AI just made it cheaper and faster. So the backlog does not clear, it explodes, because work that was never economic to do is suddenly worth doing.
The labour market is already telling this story for anyone willing to listen. TrueUp reported more than 67,000 open software engineering roles in 2026, the highest in three years and roughly double the 2023 trough. The US Bureau of Labor Statistics still projects software developer employment growing around 15% through 2034, well ahead of the average occupation. When ATMs arrived, everyone assumed bank tellers were finished. The number of tellers rose for two decades, because cheaper branches meant more branches. When compilers and high-level languages arrived, they did not end programming. They created millions of programmers. Every time we have made software cheaper to produce, we have ended up with more people producing it, not fewer.
The people calling the end of engineering are making the oldest mistake in economics. They assume a fixed amount of work to be divided up. There has never been a fixed amount of software work, and there is about to be a lot more of it.
The competitive flywheel nobody is pricing in
Here is the part I find most compelling, and it comes straight from running a software firm.
The moment one company ships features at AI speed, every competitor is forced to match it or lose the market. This is not optional. Cheaper production does not just lower your costs, it raises the minimum standard of what a product has to be to survive. The floor moves up for everyone, all at once.
So we get a flywheel. Faster output forces competitors to produce faster output, which raises customer expectations, which demands more features, more products, more integrations, more maintenance. The total stock of software in the world does not stabilise. It compounds. And every layer of that compounding stock needs humans to design it, judge it, secure it, and keep it alive. More code shipped today is simply more legacy to own tomorrow, and maintenance is the one thing AI is worst at and humans are most accountable for.
A firm that uses AI well does not fire its way to a smaller team. It out-ships its competitors and takes their market. That is a growth story, not a redundancy story.
The 70% that is fast, and the 30% that is everything
There is a pattern now so well documented it has a name. Addy Osmani, who runs developer experience for Chrome at Google, calls it the 70% problem. AI will get you about 70 to 80% of the way to a working application in almost no time at all. The CRUD operations, the standard patterns, the first draft that passes its tests, the demo that looks finished. It is genuinely astonishing to watch, and it is where all the breathless videos stop.
Then you hit the last 20 to 30%, and that is where the real work has always lived. This is the part Osmani and others now call the 80% problem: the error handling, the edge cases, the security, the rate limiting, the retry logic, the audit logging, the way the feature behaves when production traffic and real users and a compliance audit all hit it at once. AI systematically skips this layer because it lacks the persistent context to know it matters, and the analysis shows AI-generated code shipping more bugs, worse readability, and more performance issues when that final stretch is left undone. Retrofitting it later costs more than building it right the first time.
I see this every week. The first 70% arrives in an afternoon. The last 30% is days of a senior engineer’s judgement, and it is the difference between a demo and a product a customer will actually pay for and trust. Code review has quietly become the new bottleneck, and that bottleneck is staffed by exactly the people the doomers say are about to be unemployed.
This is the crux of the whole argument. AI made the cheap, fast, visible part of the job nearly free. It did nothing to the expensive, slow, invisible part, which is where products are actually made production-ready. So you get a flood of 70%-finished software and a desperate need for the humans who can carry the rest of the way. The bottleneck did not close. It moved, straight onto the desks of skilled engineers.
What the job actually becomes
I want to be honest about what is changing, because the bull case does not require pretending nothing is.
The work is not disappearing. It is moving up the stack. The value has shifted away from typing code and toward the things that do not compress: understanding what the customer actually needs, designing systems that survive contact with the real world, reviewing output that is, in the words of most developers using these tools, almost right but not quite, and owning the outcome when something fails at two in the morning.
There is a study worth sitting with here. In 2025, METR ran a controlled trial on experienced developers using state-of-the-art AI tools on code they knew well. The developers felt about 20% faster. They were actually 19% slower. The generation got quick, but the reviewing, correcting, and reconciling did not. That gap is the whole ball game. It is exactly where the scarce, well-paid human now sits, and it is exactly why the bottleneck moved up rather than vanished.
The engineer of the next decade is less a typist and more a conductor, a reviewer, an architect, and the person who carries the accountability a machine cannot. That is not a smaller job. It is a bigger and frankly more valuable one.
The junior question
I want to deal with the strongest objection head on, because a thoughtful reader will raise it immediately. What about the juniors? Commentators are saying nobody will employ them, and the data gives them some cover. Employment for developers aged 22 to 25 has fallen nearly 20% since late 2022, while developers over 26 held steady or grew, and that split is not random. The junior role was historically defined as exactly the work AI commoditised first: boilerplate, simple CRUD, scripted tests, routine bug fixes. The traditional on-ramp genuinely narrowed. If you are starting out right now, it is a harder market than it was three years ago, and I will not pretend otherwise.
But “nobody will employ them” is a claim about the long run, and it breaks on one simple fact. There is no such thing as a senior engineer who was never a junior. Seniority is not a certificate, it is accumulated judgement, and judgement only comes from years of doing the work and owning the consequences when it breaks. An industry that stops hiring juniors is eating its seed corn, and the bill arrives in five to ten years when the senior pool ages out with nobody trained to replace it. This is not a fringe worry: senior Microsoft engineers are warning that AI is hollowing out the junior pipeline, the exact mechanism that produces tomorrow’s seniors.
So here is what I think actually happens. First the dip we are in now, real and painful for the cohort caught in it. Then a correction. The firms that cut juniors to the bone discover they have a senior shortage they cannot hire their way out of, because no one grew the replacements. Senior wages spike, and the moment senior talent gets expensive enough, training a junior becomes the cheaper option again. The market self-corrects, just with a brutal lag.
The definition of junior changes too. The old junior proved themselves by writing code. The new junior proves themselves by orchestrating, reviewing, and verifying it, by being the person who can tell when the AI’s confident-looking 70% is quietly wrong. That is a higher bar to start, but a faster climb for the ones who clear it, because the tool strips away years of grinding syntax and lets them spend their time on judgement far earlier.
And this is where I come out as an operator. This is a contrarian hiring opportunity, and a clean one. While competitors freeze junior hiring out of fear, the firms quietly hiring juniors right now get them cheaper, build loyalty, and own a senior pipeline in five years that the panickers simply will not have. You are buying an asset everyone else is selling at the exact moment it is mispriced. The crowd is reacting to a visible short-term cost and ignoring a structural long-term scarcity, which is precisely where the edge always is.
The bottom rung is real, and right now it is broken. But it gets rebuilt, higher up and with a steeper first step. The honest risk is not that juniors become obsolete. It is the timing gap, a few hard years where the industry under-hires and then scrambles to fix a pipeline it broke. That cost is real for the people living through it, even as the aggregate works itself out.
The offshore question
There is a second northstar doing the rounds in Australian boardrooms, and I think it is half right and half fantasy. The goal goes like this: a lean team of senior, AI-enabled developers, onshore, in the office, and out go the juniors and the offshore teams. It sounds clean and it photographs well in a strategy deck. The problem is the maths.
Australia already runs short on experienced engineers, with the sector facing a projected shortfall of hundreds of thousands of digital workers by 2030 against only about 7,000 IT graduates a year. Now imagine every business at once deciding it wants only seniors, AI-enabled, sitting in a Sydney or Melbourne office. Demand for a fixed and scarce pool spikes vertically, wages chase it, and the only firms who actually win that talent are the ones who can pay top of market and carry the brand to attract it. That is maybe the top 20 to 30% of the market: the banks, the miners, the funded scale-ups. The other 70% are competing for people who do not exist in sufficient numbers at a price they can afford. The all-senior, all-onshore model is real as an aspiration, but as an operating model it is unreachable for most of the businesses chasing it.
Then comes the claim that AI-enabled onshore seniors can simply replace offshore teams. I question this hard, and I do it from the operator’s seat. AI is a productivity multiplier, and it lands on onshore and offshore engineers equally. It does not preferentially favour the Australian senior. So if an AI-enabled senior is twice as productive, an offshore senior at a fraction of the cost is now doing twice the work at that same fraction of the cost. The arbitrage does not close, it widens, because a multiplier on a lower cost base throws off more margin, not less.
The whole “AI kills offshore” thesis quietly assumes offshore was only ever cheap junior bulk labour. For a body shop, that is true, and AI does hollow it out. But the better offshore firms are not body shops. They run senior engineers who are usually at the very front of AI-enabled development, and the structural wage gap between, say, Indonesia and Australia is the one thing AI cannot touch, because it has nothing to do with code and everything to do with cost of living. The numbers bear this out: the global offshore market is still growing, not shrinking, and an AI-enabled offshore senior still lands at a fraction of the fully loaded cost of the onshore equivalent. So the honest question is not whether onshore can replace offshore. It is why a business would pay multiples more for the same AI-enabled seniority onshore when the cheaper version exists and ships the same work.
And here is the part the doomers miss entirely. The onshore shortage feeds the offshore case. If 70% of Australian businesses cannot get senior talent onshore, where do they actually go? The impossible onshore northstar is the single biggest tailwind a senior, AI-enabled offshore team has, especially one in a time zone that overlaps the Australian workday.
I will give the one real risk its due, because a good client will raise it. The genuine threat to offshore is not that AI makes offshore worse. It is that AI shrinks total team size so far that the saving stops mattering. If a build that needed twenty people now needs three, a business might keep those three onshore for control, because the dollars saved no longer justify the coordination. That bites on small, self-contained projects. It does not bite on larger builds, ongoing product work, and multi-team programmes, where the headcount stays big enough that a structural saving on every seat is real money. And for the budget-constrained majority, the alternative to a cheaper team is not an expensive one, it is not building at all.
So I would stop fighting on the word offshore, because that is the term the doomers have loaded up. The real offer is senior, AI-native engineering at a structurally lower cost base, in a time zone that works. The losers in this shift are the junior-heavy body shops, onshore and offshore alike. The winners are senior, AI-enabled teams wherever they happen to sit, and the offshore version is simply a cheaper version of the same engineer the onshore market cannot supply.
How I am positioned
I do not invest in stories. I invest in where demand is going, and I try to be on the right side of an obvious mistake when the crowd is making one.
The crowd is reading a 14x explosion in output and concluding the producers are obsolete. I read the same number and see a tidal wave of work that someone has to plan, review, and own. The pool of engineers is not shrinking. It is growing, the value of the work is rising, and the firms that learn to ride this flywheel will not disappear. They will be among the great compounders of this decade.
Software has been eating the world for twenty years. AI just handed it a much bigger appetite, and it still needs people to do the eating.
