We’ve Been Here Before

I understand the fixation on prose though. Language machines, by their very nature mean you type words in and text comes back out. Everyone can read the result, so everyone feels qualified to judge it. But I think that this is a category error.

Judging AI on the quality of its prose is a bit like judging Excel by how neatly it arranges numbers. What actually matters is what Excel lets people do it’s the same for these new tools.

For teams using AI tools every day, the interesting work moved beyond half-decent emails a while ago. They are analysing data, automating workflows, and writing custom scripts to modify or extend software they already use. Tools like Claude Code and Cowork are collapsing hours of tedious white-collar work into minutes, multiple times a day.

The thing people are missing is that code is also language. So when I talk about LLMs as language machines, (or rather monsters that wear language as their skin) I mean something much wider than prose.

In high fluency environments, language machines are becoming a medium for making software-shaped things. Executable documents that sit somewhere between a document and a piece of software. Things you can read, but also click through and explore. They are made quickly, for local use, by people with no formal software production skills at all.

For now, these artefacts are unevenly distributed. But they are already showing up. And they won’t stay confined to power users. The production of these kinds of documents is going to become ordinary. When it does, the workplace will change in mundane ways too.

To see where this might be going, it helps to think through the arrival of another powerful workplace technology that most people still do not really know how to use: Excel.

Every Office Has A Spreadsheet Wizard

Before it was a digital file, the spreadsheet was exactly as its name suggests; a big sheet for spreading out numbers. A tedious accounting process involving, rows and columns for keeping track of what had happened. If you made a mistake somewhere in your calculations at the top of the page you had to rub them all out and start again.

Dan Bricklin conceived of the electronic spreadsheet in the late 70s to solve this exact problem. But almost immediately, on VisiCalc’s release in 1979, it became something way more interesting: A simulation machine.

Samuel Arbesman has a great deep dive on this on his blog Cabinet of Wonders but the TLDR is that as soon as users got their hands on the computational logic of the digital spreadsheet, they began using them to build models and situations. Changing variables in one place allowed them to see what would happen if, in another.

In 1984, a few years into the spreadsheet revolution, the tech journalist Steven Levy, wrote a long and fascinating article about this genre of software. Not only is this article a time capsule of computing history, it also gives one a sense for how people were thinking about spreadsheets even then:

All this powerful scenario-testing machinery right there on the desktop induces some people to experiment with elaborate models. They talk of “playing” with the numbers, “massaging” the model. Computer “hackers” lose themselves in the intricacies of programming; spreadsheet hackers lose themselves in the world of what-if. Some, like Theodore Stein of Connecticut Mutual, admit that their habit goes beyond the point of diminishing returns: “I can’t begin to tell you how many hours I spend at this,” he said. “This is my pet, in a way. Scratching its ears and brushing its code…it’s almost an obsession.”

Then, as personal computing gave way to the networked office through the 90s and early 2000s, the spreadsheet became a programmable surface for business logic.

Ordinary people, most of whom would never call themselves as programmers, started building all sorts of things; toy financial models, workflows, trackers, and forecasts. An entire shadow layer of assumptions and data got built across organisations without going through IT or waiting six months for a software vendor to ship a feature.

I’ve written before about the kinds of memory present in organisations, but the key one is database memory: a single central version of the truth that makes up the institution’s official reality. “If it’s not in the database it doesn’t exist”. But as anyone who has worked in an organisation knows what’s in ‘the system’ rarely reflects conditions in reality. So you end up in a situation where quarterly targets live in SAP, but the actual model used to plan headcount or pay rises lives in a spreadsheet. Or Salesforce may technically track the pipeline, but the real forecast is the sales lead’s Google Sheet that they update every Monday morning. These are local realities that sit one step removed from the central brain of the organisation.

Researchers have a name for documents like these: feral databases. All the unofficial but essential Excel files that grow alongside the corporate IT infrastructure and fill the gaps between the formal software system and actual work. Flexible and largely unsanctioned tools for local sense-making, outside the company’s main database memory but closer to reality.

Most people using Excel every day were never formally trained in it. Instead they picked things up via osmosis from a colleague, or by trying to solve an immediate problem and looking it up. That is how I learned, and it’s probably how you learned too. Which is why even though spreadsheets are literally everywhere, yet most people only ever touch a tiny fraction of what Excel can actually do.

Every office and team has its spreadsheet wizard, though the level of wizardry is always a relative one. My own spell inventory includes declared variables using LET, INDEX/MATCH, XLOOKUP, nested IFs, and array formulas. Other Excel magicians write VLOOKUPs for their teammates. And the people who patiently show the same colleague how to make a pivot table once a month are secular saints. All are informal authorities, and all of them are the people who others go to when a sheet breaks. All are, to give them their proper name, software developers.

Even when most spreadsheet knowledge goes no further than summing rows and columns, this partial fluency still compounds across a workforce. Together with their colleagues who knew a bit more they changed how organisations worked at a systemic level. And I think that’s why they are a good comparison for what is happening with AI.

Beyond The Prompt

In organisations where LLM use is still shallow, most people use them for only for chat, summaries, rewrites, and brainstorming. Which is like using the full potential power of Excel to make a tidy list. Which is what people do all the time. At the deeper end of the pool, LLMs can produce all sorts of artefacts: dashboards, briefs, internal tools, status pages, decision aids, and interactive explainers. Instead of asking for a fifty-page report, you ask for a thing. Instead of accepting a rubbish dashboard locked inside a SaaS product, you can produce a lightweight custom interface built for your situation over the top of a CSV export.

These are the kinds of ”things” that people in my own circles have been sending me, and they are rapidly changing how I think about what documents might be in the near future.

A few weeks ago, before a call, someone sent me some-“thing” that would once have arrived as three separate documents. A slide deck, a spreadsheet. Instead and a supporting memo, Instead I got sent a single self-contained HTML page. Which was then explored on the call to anchor the conversation. Because it was all interactive and filterable, you could sort by risk severity, expand the detail on any item, and collapse whatever you did not need. During the call, people answered their own initial questions by looking at the artefact, which led to a deeper overall discussion.

I’ve also been sent an interactive document for a book project that someone is working on. It contained the full proposal and plan, chapter summaries, notes and references, and a way to move between them all. A single webpage sitting on top of the project allowing you to explore it from multiple angles. it was made in minutes from a Claude project and flung over Telegram for my one time use.

All these things were, in the proper sense of the term, hypertext objects. None of them required a product team or a sprint cycle which has been the baseline since the 90s. Instead they were made by ordinary people using LLMs, vibe-coded if you like, but the point is not the method. The point is the class of object they produced. Executable documents that behave like applications. Made casually like spreadsheets are, and treated just as disposable.

Playable Objects

The boundary between documents and software is beginning to soften because not everything became ‘computational’ when it went digital. PDFs still preserve the appearance of paper, and Google Docs only just got the ability to have a single continuous scrolling page, despite being web-native for its whole existence! PowerPoints still preserve the sequence of a slide projector. The spreadsheet was different however as the skeuomorphic form of the ledger mutated into a simulation machine on the application of computation.

A similar kind of mutation is happening now as different kinds of data get squeezed through the language machine. I wrote a call for the return of hypermedia back in 2024, and it feels like it’s actually beginnign to happen. The AI handles the translation and the user only needs to know what sort of hypermedia they want to navigate.

Nelson, Engelbart, and that whole lineage imagined documents as interactive containers for thought. But unfortunately office computing settled on flatter forms in the 90s, I think because Boomers and Gen X’s grew up around paper. Then enterprise SaaS locked similar flat interactions into applications in the late 00s. Institutions prefer stability to possibility, which is why IT and CIOs hate feral databases.

But the hypermedia dream is returning, as a loose ecology of small, playable objects, that can be moved through rather than scanned. The shift also goes beyond single documents. A folder of markdown files or PDFs can become raw material for new software objects. An agent can generate a timeline view, a kanban board, a reading queue, a dashboard, or even a custom file browser over the same material, but the interface can change with the task.

There’s a vernacular hypermedia that’s emerging, something like what GeoCities did to the early web. Whilst GeoCities was chaotic and aesthetically terrible (much like the state of contemporary slop), it was also the moment ordinary people realised they could publish to the web. The artefacts being made now are similarly rough, and the people making them are not professional software engineers. They are the new class of spreadsheet wizard, working from copied or default patterns and partial fluency, just as we most people do with spreadsheets.

Plan Accordingly

I’ve seen spreadsheets in SMEs treated like religious icons. Full of mystery formule left behind after their wizard moved on, and nobody able to maintain or adapt them without praying to the machine god. The same qualities that make the medium powerful also make it unruly. Spreadsheets give people local autonomy, but also the potential to create business-critical files that nobody fully understands.

LLM-made artefacts will do the same. Most will be brilliant, but some will be massive liabilities. A decision aid made with bad assumptions (like spreadsheets), or five versions of the same project view slowly drifting out of sync (like spreadsheets). An elegant interface with no clear provenance or owner, and no easy way to inspect how it works.

Once ordinary workers can generate disposable software-shaped artefacts in minutes, they will also generate disposable security problems in the same amount of time. A new feral layer in the organisation with new problems involving access, data leakage, and governance. Nobody designs feral databases into existence, but things get made and stick in the gaps of an organisations sanctioned systems. LLM artefacts will do the same and will be even harder to audit than a nested IF formula. The open question for me is what kinds of unofficial artefacts an organisation is prepared to live with, before it has to unpick the mess after something has gone wrong. This sort of thing happens all the time with other software, which is why SaaS and enterprise systems exist in the first place.

One thing that worries me about the gap I’m seeing is that many of the people in organisations best placed to benefit are already missing out and can’t see the shape of the capability. Because they don’t use the tools for ideological reasons or whatever, the recent leap in available power has barely registered. Just as there are people who spend hours a day in Excel without ever learning how to do a lookup, there will be plenty of people who use LLMs every day and never move beyond prompting for summaries and rewrites. Still, I do not think this means the AI tool shift should be resisted, but we should recognise that there’s a mundane future coming where the same bot that can write a passable email can also make useful software objects.

Just as spreadsheets gave office workers a flexible computational medium for numbers, LLMs are giving them a flexible computational medium for language.

Which is the change to watch out for. Notice when you get sent your first single HTML file instead of a slide deck or spreadsheet. Note when someone in the office turns a folder of customer interviews into a navigable tool for a meeting. Because like every other vernacular technology, people will see someone else doing it, and then do it themselves.

Update 22 May: Here’s anthropic talking about How and why members of the Claude Code team use HTML instead of Markdown to produce richer, more readable, and easily shareable outputs.