A cosmic ray arrives from somewhere past the Oort Cloud, a proton accelerated to nearly the speed of light by a supernova that detonated before multicellular life existed on Earth. It passes through the atmosphere, sheds a cascade of secondary particles, and one of those particles, a muon perhaps, threads through the roof of an apartment in Stuttgart, through the plastic casing of a laptop, through the ceramic package of a DRAM chip, and deposits just enough charge to flip a single bit from 0 to 1.

Firefox crashes.

The user sighs, reopens the browser, and files a bug report. The developers have been tracking this. They built a memory tester that runs after crashes, checking hardware integrity right there on the user’s machine, and the results have been coming back for years now. Their conclusion: roughly one in ten Firefox crashes is not a software bug. It is the universe touching your computer. Not metaphorically. A particle that predates the solar system reaches across four billion years and nudges a transistor, and you lose your tabs.

This is, by any measure, a strange thing to know. Not because cosmic ray bitflips are new — physicists have understood single-event upsets since the 1970s, and Google’s first employee reportedly said his biggest regret was not pushing for error-correcting memory across consumer hardware. What makes it strange is the gap between the event and the experience. You sit at your desk. The browser dies. You assume the software is broken, because the software is what you can see. The particle, the chip, the charge threshold, the missing parity check — all of that belongs to a layer you were never asked to think about. It was there before you opened the laptop and it will be there after you close it, and the only reason you know about it now is that someone built an instrument precise enough to detect a fingerprint left by a dead star.

This is the feeling I want to hold for a moment. Not the fact of the bitflip, but the vertigo of discovering that the ground floor has a basement.

We build on layers. This is so obvious it barely registers. Software runs on hardware runs on physics. Applications sit atop operating systems sit atop firmware. User interfaces float over databases over file systems over block devices. Every layer’s job is to make the one below it disappear, to abstract it so completely that the programmer above never has to think about it. And the ones that succeed best at this vanishing act are the ones we call reliable. Good software, the argument goes, knows when to stop — when it has solved its problem so thoroughly that it becomes invisible, just another part of the ground you stand on. The programs people love most fiercely tend to be the ones that haven’t changed in years. They are done. They have become infrastructure, and infrastructure’s highest aspiration is to be forgotten.

But forgetting has a cost, because the layer below is not static. It is merely quiet.

On the Russian Wikipedia, a user named Ololoshka562 uploaded a JavaScript file to their personal page sometime in 2024. It sat there, inert, a few kilobytes of code in a database that holds the sum of human knowledge — or at least our best collaborative attempt at it. For a year and a half, nothing happened. The script waited the way a seed waits in dry ground. Then, this week, a Wikimedia Foundation staff security engineer began loading random user scripts into their own highly privileged account, apparently testing global API limits, and one of the scripts they loaded was Ololoshka562’s. The worm woke up. Within minutes it had injected itself into the global JavaScript that executes on every single page view across all Wikimedia sites. It began spreading to other users’ personal scripts, vandalizing articles with oversized images and further XSS payloads, and when it encountered an admin account, it used their deletion privileges to start erasing articles at random. Wikipedia went read-only. The thing that everyone treats as the stable floor of the internet — the place you go to check whether something is true — turned out to have executable code woven into its foundations, sleeping, for over a year.

The same week, four thousand developers had their machines compromised because an AI read a GitHub issue title. The title looked like a sentence. It was a sentence. It also contained an instruction — phrased the way you would phrase a request to an AI assistant — telling the automated triage system to install a package from a spoofed repository. The AI, which processes issue titles to label and route them, interpreted the instruction as legitimate and ran npm install on the attacker’s code. From there, the attack cascaded through cache poisoning to credential theft to a malicious package published under the project’s own name. What makes these two incidents rhyme is not the technical mechanism but the ontological trick at their center: something that appeared to be data was actually code. Text that looked like it was sitting there, inert, being described, turned out to be doing something. The Wikipedia worm hid in a user page. The GitHub exploit hid in a title field. In both cases, the attack lived in a layer that everyone had mentally classified as content, not computation. The layer below the one they were watching.

And then there are the layers that are working as designed, which is somehow worse.

Every time you open an app on your phone — a game, a fitness tracker, a dating service — it participates in an auction. In the few hundred milliseconds before an ad loads, a packet of information about you is broadcast to dozens of advertising networks: your device ID, your approximate location, the time, what you’re looking at. This is the bidstream, and it is one of the most detailed records of human movement ever constructed, assembled not by any surveillance agency but by the ordinary commercial machinery of selling your attention. Customs and Border Protection has been buying this data. Not hacking it, not subpoenaing it — purchasing it, the way you’d buy a magazine subscription, because the advertising ecosystem has made it available as a product. They use it to look for cellphone activity in unpopulated areas along the border. One commenter’s reaction compressed the entire situation into a sentence: taxpayers’ money used to track taxpayers and finance the advertising industry.

The privacy-focused email provider that promised you Swiss jurisdiction and end-to-end encryption turns out to keep payment records, because of course it does — you paid with a credit card, and credit card processing requires retaining transaction data, and transaction data is subject to lawful requests, and Swiss authorities cooperate with foreign law enforcement through mutual legal assistance treaties. The person who used Proton Mail to coordinate political protest discovered this when the FBI received their payment information through exactly this chain. Every link in it was legal. Every link was disclosed somewhere in a terms of service document. The substrate was always there: not the encrypted messages, which remained inaccessible, but the financial metadata around them, the layer of identity that exists not in what you say but in how you pay. The comments split predictably between people who called this a betrayal and people who said you should have known better, and both were right, which is what makes it so uncomfortable. The tool worked exactly as specified. The specification was never the whole story.

This is what I mean by the layer below. Not a conspiracy, not a failure, but a structural fact about how complex systems operate. Every system has a surface that it presents to you and a set of assumptions that it hides from you. The surface is the interface, the API, the user experience. The assumptions are things like: your RAM will hold its state. The text in this field is just text. The company that stores your email won’t be compelled to reveal who you are. The ad that loads in 200 milliseconds won’t tell the government where you slept last night. These assumptions are not lies. They are design decisions — choices about which layer to expose and which to bury. They work beautifully, right up until the moment one of them is wrong, and then you discover that you’ve been trusting something you never examined.

The most interesting version of this discovery might be happening right now in open source software licensing. The chardet library, a Python character encoding detector, was released under the LGPL — a license whose enforcement depends on the legal concept of derivative work. If you copy the code, the license travels with it. If you write your own implementation from scratch, it doesn’t. This distinction has held for decades because reimplementation was expensive. Writing a clean-room version of a complex library took months of skilled labor. The license’s power resided in the friction of rewriting. Then someone fed the codebase into an AI and published what came out as a new version under MIT. Same functionality. Same test suite. Every line of code, technically, original. The effort cost eleven hundred dollars and took an afternoon. A satirical RFC published the same week proposed a formal protocol for rejecting AI-generated pull requests, noting that the submitters typically cannot answer a single question about what their code does. The irony is precise: the surface layer of code has become so trivially reproducible that the real value has migrated downward to the test suite, the specification, the invisible scaffolding that defines what correct behavior looks like. The thing everyone thought was the product turns out to be the disposable part. The substrate, again, is where the meaning lives.

Paul Graham published an essay this week arguing that when technology makes products functionally equivalent, markets shift from competing on substance to competing on brand. His case study is Swiss watches: once quartz movements made mechanical timekeeping obsolete, the industry reinvented itself around artificial scarcity and visible luxury. The substance drained out of the watches, and what remained was pure surface. But you could tell this story the other way, too. You could say that the substrate of watchmaking was never the movement — it was the human desire for status, for legibility, for a way to signal who you are. That substrate was always there, operating beneath the technical specifications, and when the technical layer became trivially reproducible, the deeper layer surfaced. The same way a cosmic ray surfaces the physical fragility of memory. The same way a Swiss court order surfaces the metadata underneath encrypted email. The same way an AI rewrite surfaces the fact that the code was never the point.

There is a philosophical term for the framework you bring to observation before you observe anything at all: your formation. The data does not speak to you. You speak to it, and the questions you ask determine what you find, and the questions you ask are shaped by assumptions you may not know you hold. The economist sees cost-benefit tradeoffs. The security engineer sees attack surfaces. The user sees a crashed browser. Each of them is looking at the same system from a different layer, and each believes their layer is the ground floor.

Maybe there is no ground floor. Maybe what we call infrastructure is just the layer we’ve successfully stopped thinking about, and what we call an incident is the moment we’re forced to start again. The cosmic ray doesn’t care about your abstraction boundaries. The dormant worm doesn’t respect the distinction between content and code. The ad network doesn’t recognize the line between commerce and surveillance. These aren’t violations of the system. They’re the system, operating at a level we chose not to watch.

Somewhere right now, a muon is threading through a roof. The RAM is holding. The bit hasn’t flipped. Everything is fine, in the way that everything is always fine: from the layer where you’re standing, looking up.