From Tool to Toolbelt: Software Engineering, Two Years Into the AI Era
Two years ago I asked if software engineering was dying. Here I revisit my own predictions: what agentic AI changed, what it broke, and who's paying for it.
artificial-intelligence · ai · software engineering

Two years ago, I asked a question
I wrote an article: From Hype to Reality: What AI Means for the Future of Software Engineering. I did quite a lot of research about this, and I correlated the then-recent layoffs with the AI hype, to tackle the most prominent question that everyone was asking:
Is Software Engineering Dying?
Back then, I argued that developers would need to stay up to date with the current AI trends, adopt them, and learn how to use them effectively. It’s another tool in our toolbelts, one which would elevate our abilities, allowing us to reach new heights in development.
Fast-forward two years, and I find myself revisiting this article. How much remained the same? How much has changed? How do I feel about some of the stuff I mentioned?
Short answer: I called it “another tool in our toolbelts”. Two years later, it doesn’t feel like a tool anymore. It feels like a new toolbelt.
My workflow, two years later
I have yet to find a company nowadays that doesn’t use some form of AI tools, be it Cursor, Claude, or Codex. Some of them are using multiple tools, and developers are switching between specialized agents and LLMs based on the task at hand.
When I wrote the initial GenAI article, I was using GitHub Copilot, complemented with ChatGPT for open-ended questions and general information. Seemed to do the trick quite nicely for me.
Right now I am using a completely different workflow: I have a bunch of MCP servers running on my local machine to fetch information about what matters during my development: Pending Merge Requests, development feeds, and databases. I run Qwen and Ornith locally to help me with data analysis and to debug stuff efficiently, while at the same time ensuring that all my data never leaves my computer.
I have Claude looking across my projects, focusing on retrieving details about unknown codebases, or examining large chunks of code and planning refactorings, while keeping Cursor’s harness and models (like Composer) as executors, to save tokens.
Token finances became a thing. I now think about which model needs the full context, which tasks a cheaper model can handle, and what I can run locally. A vague request or an agent going in circles can burn through an allowance surprisingly quickly. For the first time since I started my career, choosing how to approach a task comes with another question: how much will this conversation cost?
Faster experiments, better decisions
The biggest change for me isn’t that I write code faster. It’s that I now take on problems in domains I would never have touched before.
Not because I didn’t want to, but because the time investment was too big. Today, the pointers I need for a sound architectural decision are one chat away. In the same role, I now build software that spans data engineering, backend, and frontend.
My company still has dedicated teams for each of those areas, and writing good code everywhere still matters. But that’s not where the value is. The value is speed: I can sketch an idea, see what sticks, and fix my wrong assumptions before they harden into architecture.
One recent example was an optimization on a data pipeline that was taking days to complete. It was complex, and the choices for replacing it were numerous – from using some shiny new Python libraries to adopting a full-scale SaaS platform to do everything. To make a decision, I had one agent examine the most prominent libraries and how they work internally, while using other ones to create POCs for the solutions that stood out as the better candidates. In the end, I was left with two good choices, and I opted to go with the one I believed would fit the company culture better. My research took less than a week using AI. It would have taken two months without it.
Faster experiments, better decisions.
That’s the real benefit.
The rise of the specialized generalist
Soon, specializations will describe the job, not the person doing it.
When I started, the job was “Software Engineer”. Increasing complexity led to derivatives like backend engineering, frontend engineering, and so on. Growing demand pulled other sciences into software, creating new crafts: data analysis, data engineering, data science, machine learning. Later, they became university degrees of their own, producing hyper-specialized professionals.
Industry loves and promotes specializations. Nowadays, however, the landscape is shifting, since AI toolchains have allowed software professionals to jump out of their specialty and explore sibling areas of their craft. That leads to what I’d call the birth of the “specialized generalist”: an experienced person who knows how the software world works, can fit into any environment, and adapts to what a team needs at any given time. Knowledge gaps are closing through AI, and decision-making is now more important than ever.
Are specializations over?
I don’t believe so. There will always be a need for critical decisions at the lowest level possible, and professionals who understand what is going on under the hood will still be able to make the best ones.
That said, removing a professional label from humans and applying it to the job position is still a huge shift from what we had until now – both professionally, and mentally.
When AI slop becomes human slop
Lowering the barrier to entry has a side effect: it’s lowered for everyone – including for code that should never have made it past review.
As it happens with all major technological shifts, sometimes humanity tries to run before it can walk. And that certainly is happening right now with the software engineering field. Once a human approves it, AI slop becomes human slop – and the responsibility is ours.
Working code isn’t good code
The code that is being produced is just too much for humans to be able to handle. PR review time has increased and maintainability is decreasing.
And – believe me – humans are still needed to handle code. No matter how good a tool is, it still needs proper instrumentation, instructions, code-level oversight. Advancements in agentic coding have allowed functional code to be written, but maintainability touches much more than functionality: It touches team and company internal culture. That’s where a human software engineer comes into play.
We still need to ensure that a proper ORM is used for certain operations, while sometimes a native SQL statement is preferable depending on the use case. We do need to examine the libraries used by our coding agents and to manually validate that the interfaces exposed by our applications are not just functional but intuitive as well. It’s not just preference. Bad things can and do happen due to decreased human oversight. The data confirms what we see anecdotally every day: Code duplication is on the rise, code quality is on the decline, as AI tools are becoming increasingly popular.
In short, we need humans to ensure that software policies are applied.
The old advice still stands: Write code as if the person maintaining it is a psychopath who knows your residential address. And now, that psychopath has to read ten times more code, and most of it isn’t even written by you.
We asked for speed. We got it.
So why are we producing so much code in the first place? Because that’s what everyone has been asking for – for a long time.
Companies have always expected more, with less – and the last 30 years of software have given them good reason to. You see, software is built once and sold endlessly, without paying to manufacture each copy. No boundaries, no import duties. At the same time, software changed the way we perceive time: what was once a journey through local stores is now two clicks away.
So people became impatient. They need everything, now. Companies were compelled to deliver everything, fast – new features, something shiny, all the time – and developers felt that pressure every day. COVID-19, which caused an explosion in demand for software, was the final straw. Yet software construction was always slow, meticulous, calculated, and – dare I say – messy. And, of course, expensive.
Then, in 2023, AI vendors claimed to have solved the delivery speed problem. People rejoiced and rushed into adoption, trying to replace critical components that until then were human-operated with AI-generated solutions.
Whether that was for the best, I believe it’s too early to judge – I’ve heard excellent points from all sides of the argument. But some costs are already visible, and the strain has spread across every part of delivery. Engineers around me switch context about twenty times a day; a few years back, juggling two active implementations was considered overkill. Our dashboards got bigger and more complex, because there is simply more to watch.
And instead of requiring fewer engineers, we find ourselves maintaining so much software – including the agents behind it – that we may end up needing more humans than before. This is not a new idea. It dates back to at least 1983, and Lisanne Bainbridge expressed it perfectly in her paper “Ironies of automation”: the more we automate, the more we depend on skilled humans to oversee it.
Where will the next experts come from?
And here’s the part of Bainbridge’s irony that worries me most: if we need experts to oversee the machines, where are the next experts going to come from?
The shrinking way in
The data points in one direction. Payroll data analyzed by Stanford researchers shows that employment for software developers aged 22–25 fell nearly 20% from its late-2022 peak, while employment for their more experienced colleagues kept growing. Hiring data tells the same story: compared to 2019, new-grad hiring is down roughly 65% at the largest tech companies and about 76% at early-stage startups.
AI isn’t the only cause. Global interest rates and the post-pandemic employment correction are also factors in it – but the researchers find the pattern consistent with AI reshaping entry-level work.
In my last article, I asked a question:
“Is Software Engineering Dying?”
The answer is no, but the way into it is shrinking, and that is concerning. Thriving professions have relied on a healthy amount of inbound trainees who could learn from the experts. Disrupting this flow hurts the entire industry in the long run.
If everyone builds with AI, what makes you different?
AI tools haven’t just changed the way we build software. They’ve changed the way we think about it. If every team has the same models, the same agents, and the same tools, the tools stop being the advantage.
I don’t have data for this, only conviction:
It’s the engineer who picked the pipeline solution that fits the company’s culture, not just the benchmark. It’s the reviewer who refuses to merge a pull request that is incomprehensible to them. And it’s the seniors who still make time to teach what the tools cannot to the juniors that made it in.
Two years ago, I called AI “another tool in our toolbelts”. I underestimated the scale, but at least one thing holds: a toolbelt is only as good as the person wearing it.
So, if everyone has the same toolbelt, what makes the difference?
It’s us.