There is a question I keep seeing everywhere these days:
Will AI replace software developers?
It is a reasonable question.
AI is moving incredibly fast. The capabilities we are seeing today would have sounded unrealistic just a few years ago.
AI can design interfaces, write code, debug applications, write tests, analyze data, generate documentation, deploy software, and increasingly handle tasks across an entire development workflow.
And it is getting better — much faster than most of us expected.
Naturally, this leads to the obvious conclusion: if AI can do more and more of the work that developers currently do, maybe we will simply need fewer developers.
I don't disagree that this could happen.
But I think there is another, much bigger possibility that we aren't talking about enough.
Maybe AI won't replace the developer. Maybe AI will replace the application.
Why Do We Have Applications in the First Place?
Think about how we use software today.
If you need accounting, you use an accounting application. If you need to manage customers, you use a CRM. If you need inventory management, you use an ERP. If you need project management, you use a project management tool. If you need analytics, you use an analytics platform.
There is an application for almost everything.
And there is a good reason for this: computers traditionally don't understand what we really mean. They need instructions.
So we build interfaces that translate human actions into machine instructions:
- You open an application.
- You find a menu.
- You select a module.
- You fill out a form.
- You click a button.
The application follows a predefined workflow. This model has worked incredibly well — in fact, the entire software industry has been built around it.
But AI changes something fundamental.
What Happens When Software Understands Intent?
Imagine you run a business.
Instead of opening your CRM and going through several screens, you simply tell your AI:
Show me which customers owe me money, identify the customers most likely to pay this week, send them appropriate reminders, and update their status.
If the AI can understand your request, access the relevant business data, make decisions within the permissions you give it, execute the actions, and report the results...
Why do you need to open the CRM?
The CRM still exists somewhere in the background. But you don't necessarily need to use it directly.
Now imagine your inventory. You tell the AI:
Check my inventory and identify the products that are likely to run out in the next 30 days. Find suitable suppliers, compare their prices, and prepare a purchase order for my approval.
If the AI can do that from beginning to end: why do you need to open the ERP?
This is where things get interesting. The application hasn't necessarily disappeared technically — but it has disappeared from the user's experience.
And that distinction could become extremely important.
From Applications to Outcomes
For decades, we've designed software around something like this:
Screens → Menus → Forms → Workflows → Buttons
The user has to learn how the software works. The software doesn't really understand the user's goal; it only understands the actions the user performs inside the software.
AI could potentially reverse this relationship.
Instead of:
Application → User → Action → Result
we could move toward:
Intent → AI → Action → Outcome
The user doesn't need to know which screen contains the feature. They don't need to know which menu to open. They don't even necessarily need to know which application should perform the task.
They simply express what they want, and the system figures out how to accomplish it.
That's a very different model of software.
You Don't Really Want an ERP
This thought becomes even more interesting when you look at business software.
When a business buys an ERP, what does it actually want? It doesn't want an ERP. It wants:
- Inventory to be accurate
- Purchases to be managed
- Sales to be tracked
- Customers to be managed
- Payments to be followed up
- Reports to be available
- Employees to have the information they need
- Business decisions to become easier
The ERP is simply the mechanism we currently use to achieve those outcomes.
The same applies to CRM software. A business doesn't wake up thinking: "I really want to use a CRM today."
It wants to know:
- Which customers should I call?
- Who hasn't paid?
- Which leads are likely to convert?
- Who haven't we contacted recently?
The CRM is the tool we use to answer those questions. If AI can answer them directly — and eventually take the appropriate actions — the importance of the application itself starts to decline.
This Could Be a Much Bigger Threat to SaaS
This is the part that I find particularly interesting as someone who builds software and SaaS products.
We have spent decades building specialized software: one company builds accounting software, another builds CRM, another builds HR, another builds inventory, project management, analytics... and then we connect all of them through APIs.
The modern business might use dozens of SaaS products. Every application has its own login, interface, terminology, workflow, and learning curve.
AI could potentially sit above all of this.
Instead of the user learning 20 applications, the AI could become the common interface to all of them. You might say:
Prepare this month's financial summary, identify anything unusual, check outstanding customer payments, and tell me what needs my attention.
The AI could retrieve information from multiple systems, reason over it, and present the result as one coherent answer.
The user doesn't care which SaaS application supplied which piece of information. They care about the outcome.
That could fundamentally change how we think about SaaS.
Does This Mean Applications Will Disappear?
Not necessarily.
I don't think tomorrow morning we're going to wake up and find that ERP, CRM, accounting, and other applications have suddenly become irrelevant.
There will still be databases. There will still be APIs. There will still be business logic, security, permissions, compliance, integrations, and specialized systems.
But the interface layer could change dramatically.
Today, the application is often the thing we interact with. Tomorrow, the intelligence may become the thing we interact with.
The application could increasingly become infrastructure operating behind that intelligence. And that's a subtle but enormous shift.
What Happens to Developers?
This brings us back to the original question: Will AI replace developers?
I think the answer is more complicated than simply yes or no.
AI will almost certainly automate parts of software development. Some tasks that currently require significant developer time may become nearly automatic:
- Writing boilerplate code
- Creating basic interfaces
- Writing tests
- Fixing straightforward bugs
- Generating documentation
- Setting up infrastructure
- Connecting standard services
These things are increasingly becoming easier for AI to handle.
But software development is not only about writing code:
- Someone still has to understand the problem.
- Someone has to decide what should be built.
- Someone has to understand users.
- Someone has to make architectural decisions.
- Someone has to think about security, reliability, economics, and trade-offs.
- And most importantly: someone has to understand what problem is actually worth solving.
The role of the developer may therefore change: less time writing every line manually, and more time defining systems, validating decisions, directing AI, understanding business problems, and building things that actually matter.
The Real Shift: From Building Software to Defining Intent
Perhaps the most interesting change isn't that AI can write code.
It's that AI is slowly reducing the distance between what we want and what software can do.
Historically:
Idea → Requirements → Design → Development → Testing → Deployment → Software → User
AI is compressing parts of that chain. Eventually, we may get much closer to:
Idea → Intent → AI → Outcome
If that happens, the concept of an "application" itself starts to feel different. We may still have applications, but users may not think about them as applications anymore. They may simply think about what they want done.
And This Is Where I Think the Real Opportunity Is
This isn't necessarily bad news for software companies. In fact, I think it creates an enormous opportunity.
The companies that win may not be the ones that simply build another application with more features. They may be the ones that understand how to turn intent into outcomes better than everyone else.
The question changes from:
How many features can we put into our application?
to:
How much work can our system actually take off the user's hands?
That's a very different product philosophy. And potentially a much more powerful one.
The Application May Become Invisible
I've been thinking about this a lot lately.
Maybe the future of software isn't about having more applications. Maybe it is about needing fewer of them.
Maybe we are moving from a world where humans operate software to a world where humans describe what they want and software figures out how to accomplish it.
Today:
Screens → Menus → Forms → Workflows → Buttons
Tomorrow:
Intent → Intelligence → Action → Outcome
And if AI eventually reaches something close to AGI-level capabilities, this transition could become even more significant.
So perhaps the biggest disruption from AI isn't: "AI will replace developers."
Maybe it's:
AI will make software itself abundant — and therefore make individual applications less important.
The developer may survive. The application may survive. But the way we think about software might not.
And honestly, I think that's a much more interesting future to think about.
What do you think?
Will AI primarily change the way developers build software? Or are we heading toward a world where AI makes the traditional application itself less necessary?