A software developer recently posed a question that stuck with me.
He makes his living selling software, and his concern about AI isn't primarily that AI will eventually write code better than he can.
His concern is that AI may remove the reason for people to buy some kinds of software at all.
In this case he described asking AI to create a fairly sophisticated editable TreeGrid in JavaScript, complete with things like drag and drop, moving and inserting nodes, and copying and pasting data from Excel.
Commercial components with those kinds of capabilities can sell for hundreds of dollars.
AI produced something that met his needs in about ten minutes.
His observation was simple.
He hadn't merely saved himself development time.
He had eliminated somebody else's sale.
That's a much more interesting question than whether AI will replace programmers.
I think he is right.
At least partly.
Some software really is becoming commoditized
For much of the history of software development, part of the commercial value of software came from the fact that it was difficult to create.
If you needed a specialized grid, reporting engine, export library, administrative application, or some other piece of functionality, somebody had to know how to build it.
That knowledge was scarce.
Scarcity creates value.
AI is rapidly changing that equation.
A small business may not need every feature in a large commercial package. It may need four or five particular functions.
If the owner can describe those functions to AI and receive an application tailored closely enough to the business, some traditional software sale really may disappear.
The same thing applies to developers.
If I need a utility or component that I once would have purchased for several hundred dollars, but AI can create something that satisfies my particular requirement in an afternoon, or even ten minutes, there is a good chance I will use what AI created.
We shouldn't pretend otherwise.
The point is that the economic value of "I know how to write this code and you don't" is declining rapidly.
But I don't think that is the end of the story.
I think it exposes something that was easier to overlook when the code itself was expensive.
Working software is not the same thing as a product
AI can create surprisingly impressive working software very quickly.
That's real.
But there is an enormous difference between software that works when you try it and software you are willing to ask hundreds or thousands of people to depend upon.
Suppose AI creates a TreeGrid for me in ten minutes and it works beautifully.
Now give it to 500 customers.
One pastes 30,000 rows from Excel.
Another pastes formulas.
Someone uses a different browser.
Someone runs Windows at 175 percent scaling.
Someone drags a parent node underneath one of its own children.
Someone works entirely from the keyboard.
Someone feeds it Unicode nobody considered.
Someone expects undo to restore not only the text but the exact hierarchy.
Someone upgrades a framework six months later.
Someone discovers that if they edit a cell and immediately drag the row, something occasionally disappears.
Now I have a product.
Products live in a world that a ten-minute demonstration does not.
The hardest requirements are often missing from the prompt
There is an easy response to this problem:
Just write a better prompt.
Tell AI exactly what you need.
That certainly helps.
But it overlooks something fundamental about product development.
Very often, we do not know all the requirements when we begin.
We discover them.
A customer does something we never anticipated.
Two parts of the system interact in a way nobody expected.
A perfectly reasonable fix in one place causes an unexpected regression somewhere else.
A screen that looks excellent does not print properly.
Something that works with the mouse fails with the keyboard.
A rendering fix works in one product but introduces inconsistency in another.
You cannot put every one of those requirements into the original prompt because you do not know they exist yet.
Much of serious software development is the process of discovering the questions that should have been asked.
That changes what becomes valuable when AI makes answering programming questions cheap.
So what are you really buying?
Consider a mature commercial software component.
It's tempting to think that its value is represented by the source code.
But that's only part of it.
What you are really buying includes every strange customer report the developer already investigated.
Every regression that was found and prevented from returning.
Every browser inconsistency somebody already dealt with.
Every performance problem someone discovered under real load.
Every security assumption that was challenged.
Every upgrade that had to be survived.
Every integration problem that forced the architecture to improve.
Every edge case that somebody else encountered before you did.
In other words:
You are not just buying the lines of code. You are buying all the bugs somebody else already found.
That accumulated knowledge doesn't disappear simply because AI can produce the first implementation quickly.
Code is getting cheaper. Confidence is not.
This suggests that the economic value of commercial software is moving.
It is moving away from the mere ability to create an implementation.
It is moving toward things such as:
- judgment;
- architecture;
- reliability;
- integration;
- testing;
- security;
- compatibility;
- maintenance;
- documentation;
- support;
- and accountability.
None of those things are immune from AI.
AI can help with every one of them.
But that's different from saying they become instantaneous.
A reliable product is often the accumulated result of hundreds or thousands of decisions made while the product encounters reality.
AI can make every iteration faster.
It cannot eliminate the need for those iterations.
AI can make the wrong road cheaper too
There is another consequence of AI productivity that deserves more attention.
AI doesn't only reduce the cost of building the right thing.
It reduces the cost of continuing to improve the wrong thing.
Give AI an existing implementation and ask it to make that implementation better, and it often will.
It can refactor it.
Add features.
Patch edge cases.
Improve performance.
Clean up interfaces.
Add tests.
That can be extraordinarily useful.
But local improvement is not the same thing as architectural correctness.
You can make an inferior architecture steadily better for a very long time.
AI makes that easier than it has ever been.
Sometimes the most important programming question is therefore not:
How can we improve this code?
It is:
Should this code continue to exist?
That is one of the places where being the programmer in charge still matters.
So what will people continue to pay for?
I do think some categories of commercial software will be squeezed badly.
Generic utilities and simple applications whose primary value came from implementation difficulty are particularly exposed.
There will also be much more "good enough" software because AI makes it possible for people with limited programming experience to create tools tailored to their own needs.
That's not a future possibility.
It is already happening.
But I don't think that means commercial software becomes worthless.
It means software companies have to understand more clearly what they are selling.
If the answer is simply:
We know how to write this code.
That is becoming a weak position.
If the answer is:
We have spent years learning everything that can go wrong with this problem, and we have built that knowledge into something you can depend upon.
That is a very different proposition.
For decades, software companies could charge partly because code was expensive to create.
That advantage is disappearing.
The companies that remain valuable may be the ones that learn to sell what was hiding behind the code all along:
judgment, experience, reliability, trust, and responsibility.
AI isn't making software worthless.
It is forcing us to discover what part of software was valuable in the first place.