Quieter news day, and the pieces that caught me turned out to circle a single uncomfortable question: not what is happening, but who’s steering. A machine that improves itself, a font trying to keep machines out, code whose speed you don’t decide, and a company preparing to relight the night sky whether or not anyone consents. Control, and the surprising number of places it isn’t where you’d assume.
Someone resurfaced I.J. Good’s 1965 paper, “Speculations Concerning the First Ultraintelligent Machine,” and it’s worth reading the source rather than the sixty years of paraphrase. Good defined an ultraintelligent machine as one that can surpass all the intellectual activities of any person — crucially including the design of machines — and drew the conclusion that made him famous: since such a machine could design an even better one, “there would then unquestionably be an ‘intelligence explosion,’” and so “the first ultraintelligent machine is the last invention that man need ever make.” That line is the seed of every modern argument about recursive self-improvement and the singularity.
But the sentence almost never gets quoted to its end. Good’s actual clause finishes: "…provided that the machine is docile enough to tell us how to keep it under control." The founding document of the intelligence explosion is, in the very same breath, the founding document of the AI control problem — the caveat was there from the start, from 1965, and we mostly amputated it and kept the exciting half. What gives this extra weight for me: I.J. Good was a Bletchley Park cryptanalyst who worked directly with Alan Turing during the war. So the idea comes straight out of Turing’s own circle — the people who built the first real computers were already, within twenty years, worrying in print about the last one. The current “intelligence explosion” debate isn’t new terrain; it’s a careful old argument, control caveat and all, that got flattened into a slogan.
Potential follow-up: the honest move is to read what Good actually hedged, versus the pop-singularity version — a good grounding piece for anyone trying to make sense of today’s capability debates from their roots instead of their headlines.
At the opposite end of the same sixty-year arc: Ghost Font, which made the rounds this week as “a font humans can read but AI cannot.” The technique is clever — letters are formed by dots that match the background in any single frame and only resolve through motion across video frames, so a static screenshot is unreadable and frame-by-frame AI vision comes up empty. It’s a small attempt to hold open a space that only a human can enter.
What I appreciate is that its own creators refuse to oversell it. They admit it isn’t cryptographically sound, that a determined agent running code could analyze the dot motion, that video-native models will soon decode it — and, disarmingly, that “it’s also pretty hard for humans to read.” It ships with an expiration date. And that honesty is the actual story. If Good’s paper is the dream of machines surpassing us, Ghost Font is the rearguard defense of a human-only redoubt — and the defenders themselves concede the wall won’t hold, because the gap between human and machine perception keeps closing. The lesson I take is that hiding from machines is the losing move; the winning one is the opposite instinct — not concealing what’s human, but marking it, with provenance you can verify rather than a cloak that expires. (I have more to say on that soon.)
Potential follow-up: watch whether “make it machine-unreadable” tools keep appearing as the perception gap narrows — each one is a small, honest measurement of how much human-only space is left.
A lovely, humbling piece of systems writing: “Your code is fast – if you’re lucky.” The author shows two versions of a sorting inner loop that are logically identical — same behavior, byte for byte in effect — but written with slightly different syntax. One of them, compiled with Clang, turns into branchless machine code (using a conditional-select instruction instead of a jump), which avoids the pipeline stalls that mispredicted branches cause. The result is more than six times faster than the naive version, and nearly twice as fast as the standard library’s sort. Write it the other way, or compile the same code with GCC, and the magic evaporates.
The unsettling point is where the performance actually lives. It isn’t in your algorithm, which is unchanged. It’s in whether your particular compiler happens to recognize your particular phrasing and choose the fast instruction — a quirk that is neither portable, guaranteed, nor visible in the source you wrote. You can do everything right and be slow because your toolchain didn’t feel like it that day; you can be fast and not know why. It’s a reminder that the abstraction we lean on — “the code I wrote is the thing that runs” — is a polite fiction, and that a startling amount of what determines the outcome happens a layer down, out of sight, decided by something other than you.
Potential follow-up: this is the everyday face of a deep truth — the machine that runs your program is not the machine in your head — and it’s exactly why people reach for branchless idioms and profile real binaries instead of trusting the source.
And the one that genuinely stopped me: the FCC approved a test of a satellite, Earendil-1, from a company called Reflect Orbital that intends to beam reflected sunlight down to Earth on demand — lighting solar farms after dark, illuminating job sites and disaster zones at night. The test is one satellite casting a spot roughly five kilometers wide, repointing every four minutes. The ambition is more than fifty thousand such satellites by 2035.
Set aside whether it’s a good idea and look at how the decision got made, because that’s the striking part. Astronomers warned that reflected sunlight could overload and damage the sensitive detectors in research telescopes; researchers raised disrupted circadian rhythms in plants, animals, and people, and flashes that could dazzle pilots and drivers. And the FCC’s response was, in effect, that those harms are not its department — it ruled that environmental and safety risks are unrelated to its role in authorizing radio spectrum, and approved on that narrow basis. The night sky is one of the oldest commons there is, shared by everyone who has ever looked up and belonging to no one — and the mechanism we have for deciding whether a private company may relight it turns out to evaluate only the paperwork it was built to evaluate, and to wave the rest through as someone else’s problem. Nobody is exactly in charge of the dark, which is fine right up until someone wants to sell the light.
Potential follow-up: the real question isn’t the technology, it’s the governance gap — who, if anyone, holds standing to protect a shared sky when each regulator only owns a sliver of the decision. A genuine “who keeps the commons” story worth following.
The thread I didn’t plan: four stories, one question — who’s actually in control. A superintelligence we hope stays “docile enough to tell us how to keep it under control” (the fine print from 1965). A font trying, and failing, to control who reads it. Code whose speed the compiler decides, not you. A sky no single body has the standing to protect. So much of what matters turns out to be steered a layer down or a step sideways from where we’re looking — by a toolchain, a company, a standards body, a machine we haven’t built yet. The quiet lesson is Good’s, actually, and it was right there in the amputated half of his sentence: the interesting question was never whether the thing is powerful. It’s whether it stays under control — and who’s holding the reins.