The future of software
In times like these there is no shortage of predictions about where the world of software is heading to. The end of SAAS. The end of software developers, everybody will be writing software and there will Software Factories, spec goes in, working software pops out.
Without a doubt, a lot is going to change in software development, but, as they say in french, "Plus ça change, plus c'est la même chose"
The past
If you are like me and have spent a long time in an industry where software is an important part of the products of that industry, I think you have looked at agents writing code the same as I did: like a cartoon character, chin on the ground and eyes popping out in front of your face. What has happened to software writing with the arrival of AI to is incredible, irreversible and gobsmackingly fantastic. And then you slap yourself on the front for having wasted years of your life chasing bugs, debating with product managers, abandonning projects going nowhere etc. What a waste.
The future
But AI is awesome and developing software with AI is awesome. Not the part where you are waiting for the agents to finish while scrolling on your phone, but the part where you can finally boost your ambition again about what you are going to build. And a lot of software is going to be build, almost all of it with the aid of AI and a lot of it incorporating AI models and to a large part designed to be used by AI agents.
Is SAAS dead ?
Not necessarily: software that offers useful functionality to its users at a reasonable price will stay. Even if I can, why would I write my own version of whatever package if I can get a subscription for it at a reasonable price.
No more developers ?
Understanding software architecture remains very important. No Code of Low Code tools will grab a part of the market, but mainly at the low end for relatively simple apps. Traditional sw companies will embrace AI to increase productivity, but will not disappear.
Software is a lot more then writing code. When compilers became a thing did assembly coders had to fear for their jobs ?
Domain knowledge and data
If you have data and domain knowledge you will be able to build on that by using AI and offer new services based on that: examples of this are medical records, legal data, hotel occupation data etc. This where we see a lot of the new AI companies. And where before the development of a complex system could not be considered because of the cost, this has changed completely.
No more multi million failures
Customers will not longer accept / order huge projects that typically have budget overruns and delayed delivery milestones. Customers will still outsource but expect dramatically lower prices and better quality.
Natural language interface
New software that faces an end user will have to have a natural language interface at least for the complicated interactions (simple interactions are often still easier done by clicking something for example). A lot of new software will no longer be end-user facing, but developed for agent interaction.
The "Junior Pipeline" Crisis
Data shows a serious decline in entry-level job postings since 2022. If AI handles all the "easy" junior tasks (tests, boilerplate, simple bugs), the industry is struggling to figure out how to train the next generation of Senior Architects.
The Maintenance Debt Explosion
AI allows us to generate code 10x faster, but it doesn't necessarily make it 10x easier to maintain. Companies are waking up to "AI Legacy Code"—mountains of generated software that no single human fully understands. Observability and Automated Refactoring are becoming the most critical parts of the stack.
Security & "Agentic Governance"
It’s no longer just about firewalls; it’s about "Prompt Injection" at scale. When software is developed for agent interaction, the security risk shifts to intent. Companies must now acquire skills in "Agentic Guardrails" to ensure one agent doesn't trick another into leaking data or emptying a corporate wallet.
The long tail
Many situations or processes for which it was hard to justify a targeted software development, will be reconsidered
The present
Reality check
Coding agents are fantastic and will get better, but no matter how good they get, the developer will want to know what they have made to understand the features, the quality and the security of what has been made. Coding agents are no mechanistic compilers, so you cannot just assume that everything will be ok, but proofreading the entire codebase is no guarantee that something dangereous or stupid will not have escaped your attention. And your attention will quickly get bored in the process as well.
A second point that people have become aware of, is that coding agents are strong at certain points an weaker at others. Chasing and solving bugs is definitely an area where they have proven to be very efficient and clever. But the design phase of a project is a much harder nut to crack for most agents and in my experience often results in elaborate bs whereby the agent gets lost in intricate details so that it sometimes takes a while before you realize he hasn't got a clue what he is doing.
Also as systems become large, an agent has to keep a lot of context alive. This becomes inefficient and expensive as many dev labs have experienced.
Designing is hard
Designing is a high level function. As you start you only have sketchy ideas what the system will look like then you make it more and more explicit. In the process you will often backtrack and change major aspects of the system. Another feature of systems design is that the design of a system with the same specs, done by two people will often be very different as there are a many, many degrees of freedom in a design even if you are guided by 'best practices'.
Me and my AI buddy need a tool
I need a tool to be able to specify as clearly as possible what I want from a coding agent. And not just prompts, that can drift and get out of date, but a blueprint that is the actual representation of the artefact. A tool that I can use to easily find my way in the code to understand it. Where I can see what the subsystems are and how they interconnect.
And my AI buddy also needs a tool so that writing the code for a big system can be chopped up in manageable pieces backed by an architectural reference to keep the big picture visible.
On top of that I want to be able to catch any security breaches from the code written by the agents and if my software has to have an interface to a user-agent, I want to be able to precisely control what it is allowed to do and not allowed to do with the system.
You probably understood already: vmblu is that tool.
Conclusion
Writing software will never be the same again. And it would be wrong to try to slap old habits to the new way of writing software. It all has changed at the same time: the advent of AI, the way software is being used by humans and agents, and the way software is being built by humans and agent. But the fundamentals remain: you do need to understand what you want to build and you do need a good design to build it. "Plus ça change, plus c'est la même chose"