Interfaces that hide complexity. Convenience and opacity are the same thing

For years I've watched each new interface ask me to know less in order to do more, and the deal convinces me less every time. Punch card, command line, window with icons, phone app, and now a box where I type what I want as if I were talking to someone. The promise is always the same: you relax, I'll handle it. The problem is what that promise hides. The convenience of not having to understand the machine and the opacity over what the machine does are the same reality seen from two angles. You can't buy one without the other. And the bill, when it comes, isn't picked up by the manufacturer.

The chain that only points one way

If you order interfaces by how much they demand of the user, you get a clean slope. Whoever operated with punch cards in the forties and fifties was, quite simply, the engineer: they had to know the processor's architecture, there was nothing between them and the machine. The assemblers of the fifties let you think in symbols rather than binary, but the user was still an engineer. With FORTRAN, COBOL and then C, around the sixties, you could already reason about algorithms without holding the processor's registers in your head.

Then came the command line —Unix, DOS, the seventies and eighties— and for the first time the operator could be a non-programmer: memorizing commands was enough. The graphical interface of Macintosh and Windows, in the eighties and nineties, dropped even that requirement: you manipulated visible icons instead of recalling instructions, and the user needed no technical training at all. The phone, since 2007, reduced the interface to gestures and taps, within reach of anyone who could read. And the conversational assistant, since 2022, edges toward ordinary language: now it's enough to know how to voice a wish, by speech or in writing.

Each rung removed a competence that had been compulsory. In exchange, it multiplied the people who could use the system. The command line served a few thousand; the graphical interface, tens of millions; the phone, billions; the assistant, in practice, every literate person on the planet. The adoption curve and the technical-ignorance curve rise together. It's no coincidence: they're the same curve.

Why convenience charges in opacity

That this happens isn't a design flaw that will one day be fixed. It's a property of the thing. For the user to handle less, the system has to handle more, and what the system does on its own falls, by definition, outside the user's attention. The more convenient, the more in the dark.

You see it well if you walk the same chain watching how much the machine reveals of itself. With punch cards it was all visible: each operation had its card, which you could hold in your hand. At the Unix console it largely still is —each command leaves an observable effect, the file system can be walked, processes can be listed. With the graphical interface the machine starts to fade: background processes work without a sign, files are saved in a hierarchy the user need never know. On the phone it's already almost entirely behind the curtain: storage, network, battery, permissions, all managed by layers almost nobody inspects. And with the conversational assistant it disappears completely. You ask for something in natural language and receive an answer, with the computation underneath never showing itself at any point.

Te'eni and Sani-Kuperberg named this tension twenty years ago. Their argument is that real usability lies not in hiding complexity but in letting the user move between levels according to what they need at each moment. If everything is hidden and there's no way down to the level below, the user loses control the instant the level above fails. If everything is exposed, they drown. What's good is the passage, not total opacity or total transparency.

The industry chose, almost always, the opaque side. For money, above all: opacity lowers the barrier to entry and widens the market. What's nowhere to be found is the pedagogical incentive. It pays no one to train users capable of descending to the level below. And so it manufactures users who handle only the surface and are left with no resources the moment the surface cracks.

The query as something that also gets delegated

Up to here, what the layers hid was the technical workings. The conversational assistant hides something else, which is why I treat it apart: it hides the question itself.

Framing a query well is no formality. You have to break the problem down, find the variables, choose the right words, form an idea of what answers would be reasonable. A Google search, a database query, an instruction crafted for a model, all demand that prior work, and whoever does it well finds something while whoever does it badly is left empty-handed. It's tiresome work. That's why taking it off your hands sells so well.

The conversational interface pushes exactly there: toward making framing unnecessary. You blurt out an approximate wish and the model interprets, completes, fills the gaps. Autocomplete, instruction suggestions, the regenerate button, the so-called agentic modes that carve up the task for you —everything aims to spare the user the effort of thinking what they're asking. And there's the change in nature. The earlier layers took away the form: how the command is written, where the file is saved, which menu reaches the option. This one takes away the content: what to ask, how to split the task into pieces, what counts as relevant. If you stop thinking the query, you've stopped thinking the problem, because the query was the moment the problem got articulated.

What atrophies when it's not used

Four skills go unexercised when framing is delegated. Whoever asks the model «help me with this» receives the decomposition of the problem already done and doesn't learn to break a problem into ordered subproblems. The choice of precise vocabulary rusts because the interface tolerates ambiguity: if any wording will do, you stop refining. The anticipation of the answer —foreseeing what result would make sense, which is what later lets you judge the result you got— goes unpractised when the answer arrives before you've imagined it, and without that prior imagining there's no criterion for evaluating what the machine returns. And active search, that going to primary sources, weighing them, gauging whom to trust, evaporates in front of an interface that aggregates and summarizes, leaving the user out of touch with what the summary simplified.

These are the four skills that separate the one who thinks from the one who repeats. Their decay is not a new hypothesis: it was already documented with earlier technologies, in Carr's work on what the internet does to the head and in Sparrow, Liu and Wegner's study of the so-called Google effect, that tendency to remember where the information is rather than the information itself. What the conversational interface adds is that it asks even less effort than those. The ground was already sloped; now it's more slippery.

Who pays, and when they find out

This is my opinion, but it doesn't float in a vacuum: it gathers what the literature on interface design and attention has long been pointing out. Convenience and opacity are one single thing with two faces, and accepting the first is accepting the second even if it doesn't appear in the contract.

For the individual the bill is concrete. In exchange for the convenience of not thinking the query, you hand over mental practice, control over the process, the ability to catch the model's errors, your own judgement. The charge is invisible because it's deferred: the atrophy shows up when it's already hard to reverse. For a society the bill is the same one summed many times over. If the base adopting the interface grows wildly and aggregate cognitive practice drops, there's less articulated thinking available for the decisions we make together. No need to dramatize to say it; just look at the trend.

There are possible moves, and they're worth looking at without enthusiasm. You can design for the passage between levels, with the system showing —to whoever asks— what the model did, what sources it touched, what steps it followed inside; the way of displaying reasoning already exists in several systems, but almost always as an option and almost never by default, which is where it would really matter. You can educate in model literacy, teaching people to frame, to evaluate, to detect what the model doesn't know; for now its penetration into formal teaching is uneven and experimental. And you can regulate, requiring the system to show a minimum of what it does, which is the direction the European AI Regulation is heading with transparency obligations that come into force in staggered fashion, still partial. Three open roads, all three half-travelled.

What is measured is opacity's effect on trust. Vaithilingam, Zhang and Glassman studied twenty-four programmers using GitHub Copilot and found something uncomfortable: the tool improved neither resolution time nor success rate, and where participants stumbled was precisely in understanding, editing and debugging the code the machine served them. They preferred it anyway, because it gave them a starting point and saved them searching. The polished surface invited acceptance without comprehension, and the difficulty stayed hidden until it came time to maintain what had been accepted. Convenience had charged, once again, in the usual coin.

Definitions

Abstraction layer. An interface level that hides the details of the level below and offers the user a simpler manipulation in exchange for not seeing what's happening underneath.

Direct manipulation. A principle of graphical interface design, formulated by Ben Shneiderman in 1983, whereby the user acts on visible representations of objects rather than invoking commands.

Agentic mode. A way of working in which the assistant breaks a task into steps and executes them on its own, rather than just answering a single instruction.

Passage between levels. A system's capacity to let the user operate at different levels of abstraction as needed, instead of fixing them in just one.

References

Te'eni, D. and Sani-Kuperberg, Z. — Levels of abstraction in designs of human-computer interaction: The case of e-mail, Computers in Human Behavior 21.5 (2005). Source of the central thesis on passage between levels versus total concealment.

Carr, N. — The Shallows: What the Internet Is Doing to Our Brains (W. W. Norton, 2010). Documents the decay of attention and deep reading associated with intensive use of search technologies.

Sparrow, B., Liu, J. and Wegner, D. — Google Effects on Memory: Cognitive Consequences of Having Information at Our Fingertips, Science 333 (2011). Study of the Google effect on memory, cited for the atrophy of active search.

Vaithilingam, P., Zhang, T. and Glassman, E. — Expectation vs. Experience: Evaluating the Usability of Code Generation Tools Powered by Large Language Models, CHI Extended Abstracts (2022). Study with twenty-four programmers using GitHub Copilot; concludes the tool improved neither time nor success rate and that the difficulty lay in understanding and debugging the generated code. https://dl.acm.org/doi/10.1145/3491101.3519665

Shneiderman, B. — Direct Manipulation: A Step Beyond Programming Languages, IEEE Computer 16 (1983). Origin of the concept of direct manipulation noted in Definitions.

Going deeper

Norman, D. A. — The Design of Everyday Things (Basic Books, 1988/2013).

Weizenbaum, J. — Computer Power and Human Reason (W. H. Freeman, 1976).

Carr, N. — The Glass Cage: Automation and Us (W. W. Norton, 2014).

McLuhan, M. — Understanding Media (McGraw-Hill, 1964). The interface as extension and as anaesthetic.

También te interesa

• El minimalismo engañoso
• Diseño orientado a comportamiento
• Ignorancia funcional
• El coste de no pensar

En otros sitios

• Nielsen Norman Group — Progressive Disclosure
• Interaction Design Foundation — Affordances