You know your work. You know which things matter, which are dangerous, what order they have to happen in, and what must never be allowed to happen at all. You have known this for years. It is the reason people ask you and not someone else.
And every day you translate it into the shapes your software will accept.
Not once, at setup. Continuously. The field that should be required is optional, so you keep a note. The status that should not be reachable from this other status is reachable, so you check. The thing you need to see next to this other thing lives in a different view, so you keep two windows open, or a spreadsheet, or a paper list on the desk beside the screen. None of this is a bug report. Nothing is broken. The software works exactly as designed, and the design was made by people who did not know what you know.
That translation is the subject of this essay. I wrote a version of it years ago and I have been carrying the argument around ever since, and I have come to think I got the important part right and the interesting part wrong.
The important part was that creation has layers.
What a layer actually is
I used to describe the layers by how close they sat to the machine. Closest to the metal is the engineering view: the code, the systems, the infrastructure as engineers see them. Above that, a working professional's view: a product designer, say, who can prototype and ship the real thing rather than a picture of it. And above that, a third layer I could not describe except by pointing at it.
Describing them by distance from the metal was the wrong axis. It sounds right and it explains nothing, because it predicts nothing. Here is the version I now believe:
A layer exists when the people standing on it can author without descending.
Layers are not strata of abstraction. They are tolls. Layer one is where engineers author, and they author natively. There is nothing underneath them to climb down to. Layer two exists because someone who is not an engineer can now build a working product without becoming one first. That is the whole event. It is not that the tools got better in some general way. It is that the descent stopped being mandatory.
This is worth dwelling on, because it is the only evidence any of us have that layers arrive at all.
There was a period, most of my career, when a designer who wanted the real thing had two options. Describe it to someone who could build it, and accept the translation loss. Or go down: learn the stack, become a partial engineer, and pay that cost forever afterward in maintenance and context-switching. The people who did the second thing were not operating at a new layer. They had commuted to the old one. Some of them are still there.
What changed was not that designers got more technical. It was that a seam appeared that you could build against without understanding what was underneath it: components, systems, tokens, APIs, and then a great deal more. The seam is what the layer is made of. Once it existed, the toll was gone, and a population that had always had judgment about products could act on that judgment directly.
That is what a layer arriving looks like. And it means the interesting question about a third layer is not "what would it look like" but "who is still paying a toll, and for what."
The third layer
The answer, I think, is that everyone still pays a toll to change how their work is represented to them.
Not the content of the work. The shape of it. Which things are nouns and which are attributes. What sits next to what. What the units are. What the sequence is. What cannot happen. All of that is currently authored by a vendor, once, for everyone, and shipped as the only option, and the vendor did not know your domain, because nobody could know every domain.
So a third layer would be an environment where the practitioner authors two things.
The representation. What the working environment looks like and what its nouns are. A cluster of backend services and the flows between them might read better as a place than as a list: buildings, districts, roads, traffic. A researcher's process might read better as something that grows: a branching structure where the live path is obvious and the abandoned ones are still visible, pruned rather than deleted. I offer those as for-instances and I will not defend either one. The point is not the metaphor. The point is who chooses it.
And the workflows. This is the half I have historically underweighted and it turns out to be the half that matters. A representation you can look at but whose workflow is fixed is still a picture. You can re-draw the city all you like; if you cannot do anything through it, you have made a nicer poster of someone else's software. Representation and workflow, both authorable, is what it means for a thing to be operable rather than decorative.
I used to reach for Winamp to explain this, and I want to keep the reference, because it turns out to contain both halves of the argument and I had been citing the wrong one.
The half of Winamp nobody remembers
If you were online in the late nineties you remember the skins. By 1998 you could dress the media player in anything: chrome, wood, cartoon characters, a fish. A community archive has since collected more than a hundred thousand of them. It is the most vivid mass-market memory of software that let you decide what it looked like, and it is the reason the word "skinnable" still means something.
What almost nobody remembers is that Winamp had two skin formats.
The famous one was bitmaps. Jordan Eldredge, who reverse-engineered the format to build a browser version of the player, calls a classic skin "a glorified set of sprite sheets": images at fixed coordinates, which "could only change appearance, not layout or add custom interactions." Nullsoft decided where the buttons went and how many there were. You supplied paint.
The other format was a real one. Modern skins were XML layout plus a scripting language called Maki, with a standard library of around sixty-five classes, freeform non-rectangular windows, custom animations, and genuinely interactive elements. As Eldredge puts it, "XML and Maki worked much like HTML and JavaScript." You could author an interface, not a paint job.
For years I told this story as a defeat. The capable format lost, I would say, because people will re-skin enthusiastically and will not learn a scripting language to do it. It was a tidy lesson and I was pleased with it.
Then I checked, and it is wrong.
Winamp's own download counters survive in the Wayback Machine, and they say the opposite. The twenty most-downloaded modern skins account for about eighty-nine million downloads. The twenty most-downloaded classic skins account for about forty-two million. The single most popular modern skin was downloaded more than twenty-four million times; the most popular classic skin, nine million. Across the independent galleries the picture splits roughly evenly: two favour classic, two favour modern. Whatever else is true, the public did not reject the capable format. They downloaded it harder.
So the lesson I had been drawing for a decade was not in the data. What is in the data is stranger, and I think it matters more.
The Internet Archive holds around a hundred and three thousand classic skins. It holds nine hundred and fifty-five modern ones.
Two formats, comparable popularity, and a survival rate that differs by two orders of magnitude. The explanation is not taste and it is not decline. It is the file. A classic skin was a zip full of bitmaps: you could unzip someone else's, see exactly how it worked, change the parts you didn't like, save it, re-upload it, and pass it on. A modern skin shipped as compiled bytecode, and most of their authors never released the source. It arrived as an artefact. You could run it and you could not open it, and the only person who could ever modify it was the person who made it.
One format produced a hundred thousand descendants and a community that is still collecting them. The other produced a few hundred survivors and a dead end.
Hold that, because it comes back later and it is the most important thing in this essay.
The honest caveats, because this is my favourite example and I would rather not be caught leaning on it. Winamp's own top-twenty modern list is thick with officially promoted skins, branded tie-ins that got front-page placement the community skins never had, so the popularity gap is probably narrower than the raw numbers suggest. The archive comparison runs the other way: the classic collection has been crowd-sourced continuously for years while the modern one is essentially a single donation, so effort is not evenly distributed there either. And modern skins arrived inside Winamp3, a release users rejected for reasons that had nothing to do with skinning; Nullsoft kept shipping the old version alongside it and eventually merged the two lines back together, which is an admission of failure written into a version number. By the time both formats stood on equal footing, iTunes had shipped for Windows and the people who built Winamp were leaving.
Neither format got a fair fight. But the thing I was wrong about is worth more than the thing I was right about. People wanted the program, not the paint. What they could not do was take it apart, and so almost none of it is left.
What you would think already exists
Here I have to be careful, because when I have described this idea to people the response is usually a list, and the list is correct.
Emacs. Forty-five years old. The paper that introduced it is titled, without irony, EMACS: the extensible, customizable, self-documenting display editor. People have been authoring their own working environments inside it since before I could read.
Glamorous Toolkit and the moldable-development crowd, whose entire doctrine is that when the problem in front of you does not feel comfortable you stop and build a custom tool "until the problem feels beautiful," and who shipped their own environment with more than a thousand such tools built during its development.
Grafana, where the dashboard is a JSON document and the practitioner really does author the view they work in. Blender, remappable to the point of unrecognisability. Tiling window managers and the whole configuration culture around them. Roblox, where the authored representation is the entire product and paid its creators one and a half billion dollars in a single financial year.
Every one of those is real. Every one of them is operable, and user-authored, and none of them is decoration.
And every one of them requires the author to be a programmer.
And then there is the one that does not fit, which is why it has to be said out loud.
HyperCard did not require you to be a programmer. That was the point of it, and it worked: people who had never written a line of code authored stacks that did real work, and did it in a representation they could see and touch. It is the closest thing to a third layer that has actually shipped to ordinary people, and it has been dead for more than twenty years.
Bill Atkinson, who built it, gave his own account of the limit: "I grew up in a box-centric culture at Apple… my blind spot prevented me from making HyperCard the first Web browser." Read that as an engineering regret and it is a small one. Read it as a statement about position and it is the whole argument: the author of the best layer-three tool we have had could only build outward from where he was standing. Even a successful descent carries the shape of the place it started.
That is not a small caveat. It is the whole thing. Emacs is not a counter-example to a third layer; it is the toll booth, with forty-five years of wear on the step. Those environments do not sit at a third layer. They are layer-one tools that emit layer-three artefacts, available to anyone who is already standing at the bottom.
Which raises the question I did not know how to ask until recently. Descending plainly works: all those things exist, and some are magnificent. So why is the result never available to the people who most need it?
Nineteen years of descents
Take the city. I have used an isometric city of backend services as my example for years, and I did it under the impression that it was hypothetical.
It is not. It is a research tradition.
In 2007 Richard Wettel and Michele Lanza published Visualizing Software Systems as Cities, and a tool called CodeCity the following year. Classes are buildings, packages are districts. Since then: islands instead of cities, for module systems. Virtual-reality versions. Versions that show the code and the data together. Versions that light up security vulnerabilities. Versions built into code review. The literature is still producing papers this year. I checked, expecting a dead field, and found a live one.
It was built commercially too, more than once. Cloudcraft draws isometric diagrams of a real cloud estate, live-scanned, updating as the infrastructure changes; Datadog acquired it in November 2022. Dynatrace auto-discovers your topology and renders it as a model you can navigate and drill into.
Nineteen years, dozens of tools, two products. In every single one, you can look and you cannot touch. Select, filter, isolate, tag, compare, hover, drill down. In not one of them can you change what the system does.
And when someone tried to make a business of exactly my example, it did not go well. Arcentry made isometric cloud diagrams with live metrics, which is the pitch almost verbatim. It shut down in March 2020. Its founder wrote in the discontinuation letter that the product's focus "would remain on Cloud infrastructure planning and visualisation, neither of which are particular high-value usecases."
I want to sit with that sentence rather than argue with it, because it is the strongest counter-argument to my own position and it was written by the person best placed to make it.
Here is what I think it means, and it is not what it appears to mean.
Read-only is not a design failure. It is the signature of a completed one-way traversal.
Every one of those cities is an artefact of somebody else's descent. A researcher, or a startup, climbed down to layer one, built the city, and handed it up. The practitioner receives it and cannot modify it, not because the authors were lazy about editing features, but because the path the author took is not available to the reader. The toll was paid once, by the author, and the artefact inherits the asymmetry permanently. You are looking at a picture taken from a place you cannot go.
So nineteen years of software cities are not nineteen years of failure. They are nineteen years of evidence that descending works and does not scale. Each one is proof that the representation is valuable enough for someone to build, and proof that building it that way produces something inert.
There is a sharper case still, and it is the one that should have stopped me years ago. In 2005 a project called Vizz3D let the user choose the metaphor at runtime: dynamically loadable metaphor classes, three of them shipped. Skinnability, in the software-visualisation domain, twenty-one years ago. Nothing came of it.
CodeCity attacks my example. Vizz3D attacks my whole idea. And I think the reason it went nowhere is instructive: switching between three vendor-authored metaphors is not the thing anyone wanted, because all three were still someone else's descent. A menu of other people's representations is not authorship. It is a slightly larger cage.
Two things I had wrong
Being honest about the evidence has cost me two beliefs I held comfortably.
The first is that this is about matching a representation to how someone thinks. It is the most intuitive version of the argument: people's minds work differently, tools assume one mind, therefore let each person have the tool that fits their mind. As far as I can tell, it is not supported.
It has a name in the education literature. The meshing hypothesis: that presenting material in the mode a learner prefers improves their learning. Pashler, McDaniel, Rohrer and Bjork went looking for the evidence in 2008 and found the two halves of the claim in very different states. People genuinely do express preferences, and people genuinely do differ in aptitude. But the interaction the hypothesis needs, that matching mode to person produces the benefit, had "virtually no empirical support." Information systems ran a version of the same experiment earlier and quit; a 1983 paper on designing systems around cognitive style is titled, wearily, Much Ado About Nothing?
I do not want to build an argument on that ground. Happily, it was never the argument.
What I actually mean is that people should be able to make the software work for them rather than being constrained by it. That is a claim about agency, not cognition. Unlike the cognitive claim, it turns its most awkward evidence into support.
In 2004 Findlater and McGrenere compared three kinds of menu: static, adaptive (the system rearranges), and adaptable (you rearrange). The static menu was the fastest, at 306.51 milliseconds against 318.80 for adaptable and 331.62 for adaptive. And when they asked people which they preferred, fifteen of twenty-seven chose the adaptable one and four chose the static one.
Read that twice. The fastest option was the one almost nobody wanted. If my claim were that a matched representation makes you quicker, this result would end the conversation. But my claim is that being constrained is itself a cost, and here are people paying twelve milliseconds a click to escape it, with full information, on purpose. In a related study, users of a version of Word they had configured themselves added ninety percent of the functions they went on to use regularly, navigated significantly better and, among the people who had previously been most intimidated by the software, reported a significant gain in their sense of control.
Twelve milliseconds is not a productivity story. It is a story about who the software belongs to.
The second belief I have given up is that people will author their own representations. I wanted this to be true. The evidence is not kind to it.
The most cited study of software customisation, Wendy Mackay's from 1991, followed fifty-one people over four months in an environment where customising was normal and expected. The barriers they reported were mostly not about skill: the top one, at sixty-three percent, was time. And the finding that matters most is one I had never registered: every single person in the study got some or all of their customisation files from someone else. Nobody authored from nothing. They borrowed, and then they adjusted.
Look at the notations that actually succeeded and you see the same thing at civilisational scale. Musical notation, chemical structure, circuit diagrams, Feynman diagrams. Not one of them was invented by the practitioner who used it. Every one was inherited, taught, and socially standardised over generations, and the practitioner's contribution was fluency, not authorship.
So the third layer is not a blank canvas, and I was wrong to imagine it as one. It is a library you fork. Expert-authored representations, distributed, adjustable, with the good ones spreading because they are good. The unlock is not authorship. It is distribution, and that is a much less romantic idea and a much more likely one.
Which is where the thing I asked you to hold comes back, and why I bothered to correct myself in public a few thousand words ago.
Winamp's capable format was more popular and it is nearly extinct. Both halves of that sentence are true and they only make sense together. People wanted the richer thing: the downloads say so plainly. But you could not open someone else's modern skin, see how it worked, and make it yours, and so nothing accumulated. Every study of customisation I can find says people start from someone else's work. One of those two formats made that possible and the other made it impossible, and a hundred and three thousand survivors against nine hundred and fifty-five is what the difference looks like twenty years later.
Consumption is not propagation. A representation people love and cannot fork is a representation with no descendants. I spent a decade citing this example as a story about effort, and it was a story about forkability the whole time.
Why the last attempt died
If a whole category of customisable software existed and then vanished, the causes had better be gone, or none of this matters.
The folk explanation is that vendors killed customisation because they could not support the variation: endless bug reports against configurations they had never shipped. I went looking for a vendor who said that. I could not find one.
What I found instead was a vendor saying something more useful. When Mozilla removed the ability to fully re-theme Firefox, they explained that authors "have to understand Firefox's complex and ever-changing UI internals, and there's little documentation beyond Firefox's source code," and that consequently "we're not able to directly fix these issues without limiting our ability to improve Firefox." In the same announcement, in February 2017, they published two numbers that tell the whole story: 0.089 percent of users ran a complete theme, and of the five hundred complete themes available, sixty still worked with current releases.
Twelve percent survival. The authors had already left. The vendor buried a corpse.
That is not a support-burden story. It is a contract story: the same toll, expressed as infrastructure. A Winamp skin worked because it targeted a fixed-size window with controls at known coordinates. Once interfaces became fluid, multi-resolution, localised and continuously shipped, there was no longer anything stable to author against. A skin stopped being a document and became a fork of the vendor's internals, and forks of internals die on the next release.
Everywhere skinning survived, it survived because a stable contract existed that was not the vendor's internals. Grafana has a data-and-query model. VS Code publishes five hundred named colour tokens: JSON in, no code out. Roblox has an object model and a market that pays for the labour. Emacs and the configuration culture have plain text files the user owns, where the author and the user are the same person and that person can absorb the breakage.
Which is the encouraging part of all this. Decoration died. Operable representation survived. Everything that persisted is a case where the authored thing does work rather than describing work, which means the move from cosmetic skin to interface-as-representation is a move toward the surviving category, not away from it.
What would have to be true
I am not going to pretend this is close, or that I know who builds it. But the evidence is specific enough that you can say what would have to hold, and specific enough to disqualify most of what will be attempted.
The representation would have to carry constraints rather than aesthetics. The largest documented effects of representation on performance do not come from representations that flatter anybody. They come from representations in which the wrong answer cannot be expressed. Zhang and Norman ran the same logical puzzle as several different physical arrangements, such as oranges on plates, rings on poles and cups of coffee, and performance improved as the rules moved out of the head and into the objects, because you physically cannot stack coffee wrongly. So the question to ask of any authored representation is blunt: can an illegal state be drawn? If it can, you have made decoration.
The workflow would have to be authorable too, or you have made a picture, which is precisely what nineteen years of cities are.
The cost would have to be paid inside the work. Not an onboarding step, not a mode you switch into. Mackay's people did not lack ability; they lacked time. And there is a well-described pattern in which people decline a demonstrably better way of working because their goal is throughput and the better way requires stopping, which is exactly what "now go build your environment" asks for.
You would start from someone else's, per the borrowing finding, and adjust.
A canonical shared view would have to survive, because two practitioners looking at different representations of the same system is a situation nobody has measured. I want to be straight about this: I looked for the study and it does not exist. Not "the objection has been answered": nobody has run it. The nearest work names the tension and declines to test it. Given that the one robust finding about customisation is that it spreads socially, I would bet shared reference matters a great deal, and I would want any serious attempt to keep a common view that any two people can reach in one move.
And it would have to beat text, measured, on the actual task. This is the condition I expect to kill the most attempts, mine included. Marian Petre studied how people read graphical and textual representations of the same programs and found graphics slower in every condition: the mean for graphics exceeded text for every single subject. Worse for my purposes, the supposed advantage of a spatial overview did not appear: the programmers who spotted structural similarities between programs "were all looking at the textual representations." Her explanation is that reading a diagram is a learned skill. What makes a diagram comprehensible is layout, spacing, clustering, what she calls secondary notation, and that sits outside the formal system entirely and "is subject to personal style and individual skill."
Her sentence about all this is the one I would put above my own desk: "The illusion of accessibility may be more important than the reality."
There is a related trap that I think about more than any other. A metaphor imports its own logic. If your services are a city, then adjacency implies relatedness and districts stay where you left them and traffic runs on roads. When the system violates those implications, the user does not experience a neutral surprise. They draw a confident wrong conclusion. When researchers tested five different metaphors for explaining encryption to two hundred and eleven people, none of them improved understanding, and some of them caused people to change answers they had previously got right. A representation is not a neutral wrapper. It makes promises on the system's behalf, and it can lie.
The bill, named in 1977
I did not invent any of this and it would be embarrassing to imply otherwise.
Alan Kay and Adele Goldberg described a computer that its owner could "mold and channel to his own needs" in 1977, and called it a metamedium. Dan Ingalls, writing about Smalltalk in 1981, put the premise better than anyone since: "Any barrier that exists between the user and some part of the system will eventually be a barrier to creative expression." Note that this is a claim about barriers, about tolls, and not about cognition. They had the axis right from the beginning.
Bonnie Nardi's book on end-user programming, from 1993, contains the single most important observation in the literature: that spreadsheets are the one unambiguous success at letting non-programmers author computation, and that they succeeded because the notation shows the work rather than the machine. She also makes a point about who we are talking about that the industry keeps forgetting. "End users are not 'casual', 'novice' or 'naive' users; they are people such as chemists, librarians, teachers, architects, and accountants." A 2005 estimate projected around thirteen million American workers doing something they would call programming, against fewer than three million professional programmers. The population that would use a third layer is already larger than the one that built the first.
Martin Fowler put the pattern more bluntly, and it is worth having in plain language because it recurs every decade. Most technologies sold as the thing that will finally remove professional programmers from the loop do nothing of the sort. COBOL was going to let managers write their own reports. Each successive wave has made the same promise with a different syntax, and each time the work did not disappear; it moved, and it stayed with the people who had already paid the toll.
And the group doing the most serious current work on this, Ink & Switch, published an essay in June 2025 called Malleable software, subtitled Restoring user agency in a world of locked-down apps, which is my premise in my own words, written by someone else, fourteen months before this draft. It opens: "The original promise of personal computing was a new kind of clay… Instead, we got appliances." They have six working prototypes and the same diagnosis I have: settings only offer what the developers thought to expose, and plugins only edit what the developers authorised. They also reach one conclusion I want to quote, because it is aimed squarely at the easiest way out of this problem. On whether AI code generation solves it: "Bringing AI coding tools into today's software ecosystem is like bringing a talented sous chef to a food court."
I think they are right, and the toll framing is why. Generation makes the descent cheaper. It does not abolish it, and it does not create the thing that is actually missing.
Because here is where I have landed on what is missing, and it is unglamorous. Design tokens became a real standard last October: vendor-neutral, interoperable, with theming explicitly solved at the level of colour. That is a genuine contract, and it is the colour contract. Nothing standardises the layer above it: what the entities are, what actions exist, what state is available, what must never happen. Grafana got away with letting practitioners author their views only because "a query returns a series over time" is a universal model that Grafana did not have to invent. Your domain has no such model. And a representation generated without one is a picture, however good it looks.
That is the real reason nineteen years of cities are read-only. Not ambition, not effort, not tooling. There was no operations contract to bind them to.
And the last word should go to Kay, who named the price in the same paper where he proposed the thing. Right after the passage everyone quotes about moulding the medium to your own needs, he writes: "The burden of system design and specification is transferred to the user."
That is the bill. Every attempt since has either paid it, by demanding its users become programmers, or dodged it, by shipping something they can only look at. A third layer is what it would mean to neither pay it nor dodge it.
Where you are standing
I have no prediction about who does this or when, and I have stopped being confident it happens at all.
What I am confident about is the shape of the ladder, because it explains where the last thirty years went and it tells you something about your own position on it.
If you are an engineer, you have never paid this toll and it is genuinely hard to see. Everything is authorable from where you stand. The frustration this essay describes will read as a skill issue, and it is not.
If you are a working professional who builds, whether a designer who ships, an analyst who models or anyone whose judgment now reaches the artefact directly, you are standing on a layer that did not exist when you started, and you should remember what it felt like before the seam appeared. That memory is the argument. You did not get better. The toll got abolished.
And if you are a practitioner with deep judgment in a domain and no toolchain, you are where designers were twenty years ago: translating, all day, every day, into shapes chosen by people who did not know your work, and being told, when you complain, that the software is working as designed.
It is. That is the problem.
Matt Hanson · November 2026