After years of decline, software-development postings have started to recover. In the United States and the United Kingdom, software developer vacancies have seen the most growth, showing signs of a “two-speed” market, where some sectors have climbed, others stalled, and almost all of the demand is centered around senior and AI-linked roles.
In the U.S., software engineering now makes up 55 percent of hiring at major tech companies, up from 46 percent in 2019, as teams compress toward experienced-led hires.
A common explanation is that AI tools can now handle the routine coding tasks that used to go to junior engineers, so companies need more people who can catch mistakes and make judgment calls, which usually comes with experience.
I’ve hired senior-first for years at Gorilla Logic, and it’s worked well. What changed is that it stopped being an advantage for a few of us and became everyone’s default, partly because the systems we’re all building now are complicated enough to need it.
That common explanation is true, but far too simple to explain a trend that’s much more nuanced. And for those who manage engineering teams, it’s important to understand what is unfolding and why.
Why Software Engineering Hiring Is Shifting to Senior Roles
Companies are prioritizing senior-level software engineering talent for three main reasons:
- Market Cooling: Stabilized salaries and lower turnover allow companies to finally hire the experienced talent they couldn’t secure during peak hiring booms.
- Architecture and Planning: Most enterprise AI projects are still in the planning stages, a critical phase requiring high-level senior oversight before execution.
- Error Prevention and Governance: While AI tools generate code quickly, experienced developers are needed to enforce security, prevent shadow agents and catch costly mistakes before they multiply across systems.
Senior-Level Demand Exists for Various Reasons
First, some companies wanted senior engineers during the boom and couldn’t get them, and now they can. Part of that shift is just the market cooling off. The big raises and bidding wars of 2021 are pretty much over, and pay has mostly stopped climbing. In most of Europe, engineering salaries rose only 1–2 percent last year, and senior software pay in the United Kingdom was essentially flat. The United States saw tech salaries increase an average of 1.6 percent in 2025.
The perks went with the salaries, like matching remote and in-office pay or handing out signing bonuses to win people over. After two years of layoffs, a lot of experienced engineers are looking for work. So part of this hiring has nothing to do with AI. The market cooled around the same time AI took off, and it’s easy to mix the two up.
The second reason is where we are in the cycle of most of these projects. Many companies aren’t running mature agentic systems just yet. They’re still working out how these systems should be built, and that planning is senior-level work. Right now, the market is mostly paying for the plan, which comes before teams can execute the build. That will shift once the systems are live and the work moves to running them.
Last, companies aren't hiring senior engineers to ship faster, as some would assume. It's the opposite. They're hiring them so that faster code does not turn into expensive cleanup later. Marco Vargas, one of our solutions architects who designs the agentic pipelines our delivery teams run, framed the pattern well earlier this year:
“AI doesn't fix your software development lifecycle; it amplifies it. Good discipline gets faster, and so does bad discipline. A bad pattern used to land in one file. Now it lands in every file the agent touched, before anyone has read a line of it.”
That’s the core reason why companies want senior developers. Cleaning up a mistake after an agent has copied it across the code is expensive. Paying for the experience to catch it early isn’t. Because when one bad call can spread everywhere before anyone reviews it, what matters most is having someone who can stop it from happening in the first place.
What You’re Investing In When You Hire Engineers
With the rise of vibe coding and AI coding tools, writing code is becoming a commodity. It’s now interchangeable and cheap to create versions that are barely distinguishable from one another. Engineering isn’t.
If anything, the experience of a skilled developer is becoming more valuable. The difference between the two, writing code and engineering, is everything we used to learn by doing the work ourselves. The industry has always run on an engineer’s ability to solve problems, built by trying something, watching it break, hitting a dead end and trying again until it works.
That’s how an engineer builds judgment, and it’s the part of the career trajectory you can’t omit. Because when the code is cheap, that judgment is what’s left, and it shows up in decisions that don’t look like coding at all.
Agents are the clearest example right now, and almost anyone can build one. Non-technical teams are using AI workflow tools like Claude Cowork to connect their own workflows that read and change data in real company systems. That’s a genuine productivity win. But a lot of those agents run on someone’s laptop, outside the company’s access controls and security, and no one’s tracking them. People are starting to call them shadow agents, and they’re piling up fast, introducing a new layer of risk.
Building an agent is easy. Knowing how to make it safe isn’t. Someone has to decide what an agent is allowed to touch and how it should behave next to the hundred other agents doing the same thing. That’s governance and security work, and it takes an engineer who’s seen how systems fail. Writing an agent is easily accessible. Making it safe to run inside a real company is the judgment you’re paying for.
How We Build Junior Roles Has Changed
Like a lot of industries, the on-ramp into this field has changed. Engineering still needs to develop senior-level experts from newcomers, but where they learn and grow will have to change. Engineers are problem solvers by nature, and this is one more problem to solve together. We need to figure out now how to train the next generation under these new conditions so demand for senior engineers doesn’t outrun supply a few years from now.
I suggest we start them on reviewing and fixing code instead of writing it from scratch. The most vital skill right now is reading what the machine produced and catching what’s wrong with it. They used to build that same instinct by writing code themselves. Put juniors on the live systems the seniors are designing, where running something real shows them what these tools do and where they often make mistakes. And when the AI gets an answer wrong, hand it back and let them work out why instead of fixing it for them.
We have to be mindful that these are the engineers who’ll run those systems once they go live, so you’ll need them either way. Developing your own bench is the smarter investment than fighting over the seniors everyone else wants. That way, you build the exact skills you need, and you know what you’re getting.
The case for senior hiring is stronger than headlines suggest. Just be clear about how much of your senior demand is really AI and how much is the price correction and the planning phase you’re in. And put real work into building the engineers you’ll need in a few years.
