Hyper-Customized One-Off Software for Cheap

2026-07-05

I discussed previously that AI projects have a short lifespan, on average.

This one is a related hypothesis, which I believe we are starting to see in the AI-adjacent software engineering domain already, and which might spill into other domains soon:

Hypothesis: With the changing economics of software creation, we will see more software which is produced on demand by its own users, with the help of AI models that are sufficiently good at building the required code based on a human prompt.

This software will be cheap, but most of all, it will have the advantage of being hyper-specialized to ther user’s needs, bringing down the integration cost.

The old world

Traditionally, we view successful software projects as a thing that few people build and many people use (1:N). It looks like this:

Authors pay for the design and implementation of the software, and sometimes for marketing and similar functions. This is expensive, but it is still profitable for authors because (1) software is easy to copy and (2) they can target a large number of users.

But users don’t only pay for the software itself, they also pay the (more implicit) cost of adoption (discovery of the right software to use, technical and practical adoption into their environment and workflows). And if they fail to adapt the software into their surroundings, it is not unheard of that such integration projects fail and result in high costs.

AI models change the economics of software development

Now that the implementation cost is shifting with AI, and implementation becomes more feasible for the user as well, there might be domains where the cost for the user is lower when building custom software ad-hoc than searching for and integrating a suitable existing solution.

The reasons are:

• The cost of implementation is much lower now (for simple software).

• The adoption/integration cost can be brought down by generating the software hyper-specialized to the user’s specific needs.

  • To drive this to the extreme, for software that is seldomly used, but benefits from subtle changes each time, you could even go as far as to generate the software fresh for each time it is used.

  • Evaluating existing software products for suitability is not needed any more, as software is now malleable for the user.

To what kinds of software does this apply?

An early indicator can be seen if you look at domains where the AI adoption is already high, e.g. in software engineering itself: If you follow web forums where people share and advertise their project creations, it is clearly visible that there is a now a large amount of projects that people create because they could (a) make it fit better to their tastes (a.k.a. integration into their environment and workflows) and (b) they were too lazy to put up with researching and integration existing solutions.

Sure, the bar to get to an implementation is even lower for people who themselves work in the field. But with improving AI models and suitable frameworks for AIs to work in, I think it’s realistic that this will come into reach for normal computer users as well.

There are some kinds of software where I think it won’t apply though:

• You can still not break through fundamental limitations in algorithms and complexity theory.

• In more practical terms: If you want to analyze a large dataset, but you are not storing it in a place with suitable querying capabilities, churning through the data brute force can quickly become expensive.

• Software or software services on which other people depend is harder to change and requires careful consideration.

• Changing such software in a “vibe” fashion is difficult without breaking or removing these dependencies. So “lower level” classes of software like databases, operating systems and other services are less malleable that way.

---

With the shifting cost economics, I think the writing is on the wall that we will see much more one-off software projects that solve much more targeted use cases for much smaller numbers of users.

And of course, as the cost for producing software lowers, this does not just replace existing software, but it also unlocks the creation of software which was previously economically unviable to produce.