For most of the history of computing, programming has been a scarce skill. A skill practiced by a small group of experts who could translate ideas into instructions a machine could execute. That scarcity created a creativity bottleneck: if you couldn’t program, your computational imagination was limited to whatever applications were already available.

But something fundamental has shifted.

We now have models that can write usable code. Sometimes imperfect, sometimes brilliant, but almost always good enough to make a computer do something new. They don’t solve every programming problem. They don’t replace expert programmers. They don’t need to.

All they have to do is handle the long tail of simple requests that have never been worth implementing. Because programming time was too precious.

And once that barrier falls, something remarkable begins to happen.

The long tail of “too small to build”

There is an enormous universe of tasks that fall into the category of:

• “I would automate this if I knew how.”
• “It’s easier to just do it manually.”
• “I can’t justify asking a developer for this.”
• “It would help, but not enough to be worth the time.”

Renaming files based on EXIF data. Generating 20 variants of a slide for a classroom. Building a tiny web UI to test an idea. Simulating a scenario. Cleaning a dataset. Scraping a niche website. Creating a custom visualization. Interacting with a local sensor. Turning a spreadsheet into an interactive tool. Editing an excel file for the umpth time.

These tasks are innumerable. They live in the margins. Where ideas happen, work happens, research happens, creativity happens. Historically, they have been erased by the high cost of expertise.

LLM-based code generation makes those tasks cheap. Not financially, but cognitively. They become feasible for anyone who can describe what they want.

This is the start of abundant novice programmability.

What professional programmers still do

To me it still seems plausible that programmers become obsolete in the long run. But we do not need to wait until then, because the effects will be profound before then and already are.

Professional software development still handles the things that always required expertise:

• building complex systems
• integrating heterogeneous components
• debugging deep, latent failures
• designing architectures that won’t collapse
• managing state, scale, performance, and security
• reasoning about concurrency, transactions, invariants
• constructing sustainable long-term systems
• interpreting ambiguous requirements
• balancing tradeoffs
• navigating the social and organisational complexity of software

LLMs handle none of this reliably. They assist, but they don’t reason deeply about complexity, scale, or systems.

Instead, they excel at generating small, local, situated computational artefacts.

What novice computational creators do

This is where the explosion happens.

A new group - the computational creatives - can suddenly:

• automate small parts of their daily work
• build quick prototypes to test ideas
• create custom data tools on the fly
• design small scripts to reorganise information
• experiment computationally with concepts
• generate interactive demos for teaching
• assemble one-off applications
• build simulations, visualisations, workflows
• adapt tools to fit personal or local needs
• compose computational behaviours like writing paragraphs

These are not “apps” in the traditional sense. They are computational expressions—micro-tools, situated artefacts, small experiments. Ephemeral, contextual, and deeply personal.

And because they can now be produced conversationally, millions of people can do them.

When scarcity disappears, creativity explodes

Whenever friction in a creative medium drops, the medium transforms:

• cameras become cheap → photography booms
• desktop publishing arrives → zine culture flourishes
• social media emerges → micro-authorship expands
• 3D printing becomes accessible → rapid prototyping spreads

Programming is now undergoing the same transformation.

We are moving from:

programming as expertise → computational creation as expression

The long tail of “not worth the time” becomes the long tail of everyday computational imagination.

People will make things they’ve never made before, because now they can. Tasks that were once impossible become casual. Computation becomes a normal medium of thought.

This does not diminish programming. It expands the space of what people can do with computers.

A new paradigm: instructional and conversational computing

When models can write code in response to natural-language instructions, the computer shifts from a static environment, defined in advance by applications, to a dynamic, emergent environment, defined in the moment by interaction.

The computer becomes:

• an instrument rather than an appliance
• a partner in exploration
• a material of expression
• a conversational surface of computation
• a medium for thought

We get not “AI that builds apps” but humans who can bring computation into their thinking in a new way.

This is computational creativity emerging at scale.

The future is full of small, idiosyncratic programs

The most transformative effect will not come from the models themselves, but from:

• the millions of small scripts
• custom visualisations
• personal micro-services
• tiny simulators
• niche tools
• short-lived experiments
• local automations
• one-off computational artefacts

that people will create because the cost of creating them has collapsed.

This is the true frontier: abundant, conversational, everyday computing.

A world where people routinely reshape computation to fit their lives, not the other way around.

(And while I’m building my envisioned LLM-mediated computing paradigm, this is already happening in other ways.)