It’s nearly impossible to discuss technology today without AI entering the conversation. And increasingly, it’s becoming just as difficult to talk about software without acknowledging a fundamental shift in how it comes into being. I’ve been observing this shift for a while, watching the patterns take shape as AI tools grow more capable, more accessible, and more deeply woven into our development practices.

The pattern I keep returning to is one we’ve seen play out before, in an entirely different domain.

Manufacturing efficiencies enable mass production. Mass production enables cost efficiencies. Push this far enough, and products become cheaper to replace than repair. That’s the genesis of disposable products - not born from deliberate intention, but from the relentless logic of economies of scale.

We’ve witnessed this unfold with consumer goods. Throwaway fashion. Single-use plastics. Electronics engineered with limited lifespans. The trajectory is well-worn, perhaps overly so.

Now the same trajectory is emerging in software.

In earlier times, we built systems that could be configured to accommodate different organisations or use cases. You acquired the software, adapted it to your requirements, maintained it through the years. The relationship between creator and user was continuous, evolving.

Now we have systems that are dynamically generated to match the specific use case. AI has become the engine of the software factory. The shift is subtle but carries profound implications.

The reality of single-use software systems is not some distant future - it may already be here. GenAI tools are producing programs and executing them with every prompt. These programs exist briefly, serve their purpose, and vanish. Code that lives for moments before being discarded and regenerated.

GenAI has delivered genuine value in searching and summarising content, in orchestrating processes through tool calls. These represent real progress. But as we push AI use cases further, AI Agents end up constructing tools dynamically and running them on demand.

For deterministic business processes - those requiring consistency, numeric precision, predictable outputs - this approach is wasteful. The emphasis should be on building tools that AI can leverage or coordinate, rather than having AI fabricate the tools as needed. There’s a meaningful distinction between AI as a skilled collaborator and AI as an unbounded production line.

Then there’s the question of repairability. When building becomes cheaper than fixing, we inevitably produce more throwaway software systems. Each prompt spawns fresh code, untested against unusual conditions, disconnected from accumulated wisdom, impossible to maintain because longevity was never part of its design.

Fast food. Throwaway fashion. Disposable goods. Systems built without repair in mind. We understand where this path leads in the physical world - damage to the environment, strain on ecosystems, waste accumulating faster than we can address it.

The technical ecosystem faces similar vulnerabilities. Disposable software carries its own burden: in computational resources consumed, in technical debt accumulated, in the gradual erosion of craftsmanship and deeper understanding.

This moment calls for a new concept of sustainability within the technology domain. The question isn’t simply whether AI can generate systems on demand. The question is whether it should, under what conditions, and with what considerations in place.

We ought to be thoughtful about the products we design and bring into existence. Software, like any artifact of human labour, should be repairable, reusable, and capable of being repurposed. The tools we build to serve our needs should not consume more than they contribute.

The enthusiasm surrounding AI is genuine, and portions of it are well-founded. But enthusiasm without careful consideration produces the software equivalent of disposable fashion - inexpensive, plentiful, and ultimately wasteful. We have the capacity to do better. And we should demand nothing less.