The WASM sandbox puts the security boundary in the Gutenberg layer where it can be enforced structurally. The 'do not click external links' policy puts it in the Semantic layer — the user's judgment — where it degrades under pressure and fails predictably at scale. One is engineering. One is hope.

The resolver that presents false certainty is more dangerous than the resolver that honestly says 'I'm not sure.' WhatsApp fraud, npm hijacking, DNS propagation gaps, QR codes, SMS links — all the same problem: the Gutenberg state changed, the Semantic layer did not update, and the resolver showed no ambiguity. The user was taken for a ride.

Muddy Waters sang about power imbalance and the authentic signal buried under noise. Muddy waterlines are the same pattern in software: the Gutenberg/Semantic boundary obscured deliberately so the Use side cannot navigate. The disappearing close button. The cookie banner designed to confuse. Chrome: the user agent that became the server spy.

Alan Cooper's 'The Inmates Are Running the Asylum' names the failure mode precisely: the engineers who built the software are now designing the interface. Not malicious. Genuinely blind to the gap between their own mental model and the user's. Proximity creates blindness. The fix is not smarter engineers — it is exposure to actual users.

Steve Krug's 'Don't Make Me Think' is the Use-Pull manifesto for interface design. Every moment of hesitation is a design failure. Every 'where is the close button?' is a bug. The interface that requires no thought is not simple — it is deeply considered, shaped entirely by the Use signal of what people actually do.

Bore-out is not burnout. Burnout is too much demand. Bore-out is too little meaning — the slow accumulation of capability misallocation that nobody notices until it is well advanced. Marvin the Paranoid Android had a brain the size of a planet and was assigned to park cars. The missing piece was not motivation. It was a resolver between capability and task.

The Gemba is the actual place where work happens. The sticky note next to the monitor is a bug report nobody filed. The workaround in the onboarding documentation is a design failure nobody admitted. Go to where the Use signal is generated. Watch without helping. Get your feet wet at the waterline.

Enshittification is what happens when the platform that built a clean external resolver discovers the resolver is an extractable resource. The Sirius Cybernetics Corporation's complaint department was the first to be transferred to another dimension. Google, Amazon, Apple, and Meta are following the same arc. The structural fix is always the same: open resolvers, portability, and competition.

Your phone number survived every phone you have ever owned and every carrier you have ever used. That is not an accident — it is an external resolver. The mechanism that lets the Gutenberg layer change while the semantic layer stays yours. And it is the model for everything else that should work this way but doesn't yet.

A one-month reflection on how a morning coffee question about ESLint configs became 30 posts on software architecture, deployment practice, and why the user does not sux. What the process itself demonstrated about the framework it produced.

The iceberg moves. Moore's Law moves the Gutenberg layer every few years. The 10% overhead of keeping the waterline clean is what lets you steer. The architect who collapsed the waterline cannot move at all — they go down with the iceberg they optimised for.

Moore's Law doubles the Gutenberg layer every two years. The waterline overhead stays at 10%. Every generation draws a ceiling at the Gutenberg layer and forgets the semantic layer keeps growing. 640K. 65536 code points. Whatever you just said will be enough.

Hadoop, NoSQL, ORMs, object databases — all promised to improve on or replace SQL. All lost. SQL survived because the separation between what you ask (semantic) and how it executes (Gutenberg) was correct from the start. And the DBA tweaking queries five years after the architect left is the proof.

The waterline between your code and the platform it runs on shifts slowly. You do not notice until something degrades. A small fix, five years later, at exactly the right layer, can recover years of lost performance — if the layers were kept separate in the first place.

Scanning for landmarks is O(1). Taking measurements is O(n). The curly brace is the brick that sticks out of the wall. Significant whitespace makes every brick flush — and hides the loose one until brick 98.

Making the technical layer invisible feels like good UX. It isn't. When the seam disappears, the semantic layer has to carry both jobs — and when something breaks, there is nothing to inspect. Legibility at the waterline is a feature, not a leak.

Deprecation is only warranted for security reasons. Old stars fade — you do not outlaw them. Python 3, .mjs, and UTF-16 are what happens when the future expert is arrogant about the past. Dijkstra deprecated goto correctly. The dual-track strategy is how you move fast without breaking things.

The web stack spent thirty years building clean Def-Use seams between HTML, CSS, JS, and HTTP. ES modules, CSS custom properties, and OpenAPI are what made specialist crafts possible. CSS-in-JS was a regression.

Gutenberg 2.1 did not fix the page size — it standardised the range. 512 to 4096 bytes, powers of two, comparable by design. The postman stays fast because the envelope is simple. Deep packet inspection, XML namespaces, and SOAP are what happens when you make the postman read the letter.

Why a bigger page never scales but turning it over does. Books, envelopes, and UTF-8 explained through the separation that Gutenberg got right in 1450.

Your lights do not know your name. Bluetooth PINs, Matter fabrics, and RDF triples all push Gutenberg identifiers across the boundary.

90 percent reasonable, less than 10 percent jerks, less than 1 percent saints. Ten independent users saying the same thing is a bug report.

Gabriel was right that worse beat better. The semantic gap is where evolution happens. Lisp machines, RISC/CISC, C++ versus C and Rust.

A 1988 Atari ST compiler that beat hand-coded assembly by keeping source structure intact. LLVM IR as a newspaper without headlines.

Accept the 10% abstraction overhead. Collect the 2x improvement every few years for free. Portability is a basket option on unknown future hardware.

Competition transmits the Use signal. Monopoly suppresses it. Government has no exit by definition. Lidl kept the supermarket honest.

IPv6 tried to eliminate NAT as an ugly hack. NAT was load-bearing. Chesterton's Fence and Conway's Law explain why removing it failed.

UUIDs belong in databases, not conversations. DNS solved this in 1983. Mum and Mrs Kervel are the same Gutenberg address seen through different semantic contexts.

Boundaries form, stabilise, drift, break, and reset. Unix to POSIX to Android Mainline to WASM. gRPC is CORBA in a hoodie.

Your email address is tied to someone else's domain. Own your domain, make the carrier replaceable. XS4All, Gmail, and enshittification.

Your music survived six formats. Your bank account number has not moved since you opened the account. Why the difference matters.

Exceptions are Def-push error handling. Result/Option and HTTP status codes are Use-pull. Thirty years of the Use signal delivering its verdict.

DuckDB separates storage from SQL cleanly. Parquet on S3, Excel, CSV all queryable with the same SQL. The dual-track strategy done right.

YAML significant whitespace is an O(n) boundary problem. JSON was designed for machines, forced on humans. JSON5 and TOML fix the Use complaints.

The kernel is Use-pull because hardware is an unambiguous oracle. The desktop is Def-push because taste is not. Android shows what Linux desktop could have been.

Sonos broke the semantic layer while the hardware was perfect. Intel's fabs fell behind. Apple switched processors three times by separating the layers cleanly.

Certification as the tribal weapon. Nokia, BlackBerry, and car infotainment all kept users locked in by owning the certification process.

MDI window management as a tribal Def defended for twenty years while tabs won everywhere else.

Authors define, users interpret. The gap between them is where waste lives. Lean Pull, the Train-ing problem, and why the user does not sux.

Every information system operates on two parallel layers: physical/positional (Gutenberg) and logical/meaningful (Semantic). The foundational framework for the series.