The creativity explosion is going to be strange, messy, and wonderful

The largest effect of cheap implementation falls outside the engineering team altogether. When building software stops being expensive, software stops being an industrial product that arrives from a vendor and begins to behave like a medium, something closer to writing or woodworking, where the barrier to trying an idea is low and what stays scarce is taste and persistence.

The result will be an explosion of creation, and the honest forecast is that most of it will be poor. Theodore Sturgeon’s law, ninety per cent of everything is crud, has never yet spared a new medium.1 The question is whether the other ten per cent, and the access that comes with it, are worth the flood.

It has happened before, in this exact shape. Desktop publishing arrived in the mid-1980s and put typesetting on every desk, and the first thing it produced was a wave of ransom-note newsletters, a dozen typefaces to a page, because the people who could suddenly set type had not yet learned how.2 Within a decade the mess had thinned and nearly all publishing had quietly become desktop publishing. The pattern is democratisation, then a flood of bad work, then maturation, and it is the pattern to expect again.

The lasting change is not more software but more personal software. For most of computing’s history software has carried an assumption of compromise: the tool almost fits, one feature grates, the workflow suits no one’s actual way of working, and it is accepted because bending the tool to the person has always cost more than bending the person to the tool. Whole roles, shadow spreadsheets and unofficial workarounds exist to absorb that mismatch. When implementation is cheap the mismatch becomes optional, not everywhere and not at once, but enough that the question shifts from which tool to buy to what a tool should do, and why it does not already.

The economics bite hardest where the mainstream persona never fit. Accessibility is the clearest case. People whose needs fall outside the assumed average, motor or visual impairments, heavy cognitive load, neurodivergent patterns of attention, have been served slowly and usually only where law or sheer market size forced it, because personalisation was too expensive to justify for a small group. Cheap implementation changes that arithmetic. A powerful home-automation platform like Home Assistant is, for many, punishing to configure; an agent can draft three dashboards built around how a particular person lives, implement one, and refine it from feedback until the interface fits the user instead of the default. The same approach extends to everyone a generic product quietly leaves out.

The people doing this need not be developers, and the precedent is older than it looks. The most successful programming system ever built is the spreadsheet: tens of millions of people who would never call themselves programmers have been building real computational tools in it for forty years, because it met them in their own domain rather than in a language.3 Product managers, designers and domain experts are placed the same way. They already think in needs, constraints and acceptance criteria, and they know where the friction lives.

The promise that anyone could build software is not new, and it has mostly disappointed. Fourth-generation languages in the 1980s, and low-code and no-code platforms since, were each sold as the end of the programmer, and each hit the same wall: the tools could not scale past the simple cases, and the people who had been burned learned to discount the pitch.4 What is different now is the interface. A conversational, iterative loop does not ask anyone to learn a constrained visual builder; it lets them describe what they want in their own words and correct it by reaction. That lowers the barrier in a way the earlier waves did not, which is a reason for cautious optimism and no more than that.

The objection that this will flood the world with bad software is correct and beside the point. The world is already full of bad software; the difference today is that the bad tool is often the only option, bought and adapted to and carried as a tax on time and attention. When building is cheap the balance shifts: people can be choosier, can customise, can replace a painful workflow without waiting on a vendor’s roadmap. That guarantees nothing about quality. It changes who controls the tool, and it raises the value of the one input that does not get cheaper, the taste to decide what a thing should be and the patience to refine it until it is right.

The title is the honest forecast. Strange, because software built for one person looks nothing like software built for a market. Messy, because most of it will be poor, as most of everything is. Wonderful, because the binding constraint is no longer whether a thing can be built but whether someone knows what they want and will stay with it until it exists. The barrier was never imagination. It was the legwork, and the legwork is what is becoming free.

---

References

1. Sturgeon’s law, from the science-fiction author Theodore Sturgeon’s defence of the genre against being judged by its worst examples (Venture Science Fiction, 1957-58): “ninety per cent of everything is crud.” https://en.wikipedia.org/wiki/Sturgeon%27s_law ↩

2. Desktop publishing arrived in the mid-1980s with the Apple LaserWriter and Aldus PageMaker (1985). Its early years were notorious for the “ransom note effect”, untrained users mixing many typefaces on a single page; by the late 1990s the craft had matured and nearly all publishing had become desktop publishing. https://en.wikipedia.org/wiki/Desktop_publishing ↩

3. Bonnie A. Nardi, “A Small Matter of Programming: Perspectives on End User Computing” (MIT Press, 1993). The spreadsheet is the most successful end-user programming system yet built, giving real computational power to tens of millions of people who would not call themselves programmers, by meeting them in their own domain rather than in a programming language. https://books.google.com/books/about/A_Small_Matter_of_Programming.html?id=0drDRT370eoC ↩

4. The promise that non-programmers could build software predates AI. Fourth-generation languages in the 1980s, and the low-code and no-code platforms since, were each marketed as the end of the programmer, and each largely failed to scale beyond simple cases. Software Improvement Group, “Low Code: wave of the future or blast from the past?” https://medium.com/softwareimprovementgroup/low-code-wave-of-the-future-or-blast-from-the-past-7fcd618371b2 ↩