Solving Futbol Like Chess

2026-07-05T00:00:00+00:00

European futbol has spent the past fifteen years solving the game like chess.

A generation of coaches optimized for pass completion, pressing triggers, territorial control, rest defense, and positional occupation. The problem is that they optimized for what is measurable. Attacking space early, attempting the difficult pass, dribbling past a defender, deliberately creating chaos: these are high-variance plays. They fail more often than they succeed. If you evaluate players by completion rate, ball retention, or positional discipline, those actions look like mistakes. So they get coached out. Eventually, everyone converges toward the same local optimum.

Nutrition Labels for Trust

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

The man in the painting at the top of this page is doing the oldest verification job there is. He is weighing each coin on a balance, one at a time, because the face stamped on a coin is a claim and its weight is the evidence, and a money changer who confused the two went broke. He does not trust the mint. He trusts the scale.

Five hundred years later, almost all of our software asks us to trust the stamp. It ships with a name, a logo, a reassuring sentence about security, and no scale anywhere. The bill for trusting the stamp comes due in supply-chain backdoors, dependencies nobody audited, and “verified” badges that turn out to have meant a marketing review, and it usually arrives late and all at once.

Vitalik Buterin put the missing scale into one sentence:

In an ideal world all software and hardware would have “nutrition labels” that provide a full list of trust dependencies - what math and which actors’ honest behavior (and on what time scale) the system is relying on to provide its core functionality and implied guarantees.
Vitalik Buterin (@VitalikButerin)</a> </blockquote>
binji replied with the obvious objection, and then with something more interesting:

even if this was available, it could still prove to create a cognitive load that is ignored by many, so they’d still opt into systems that preselect for them. you see this in nutrition labels and dieting etc, where most people prefer the convenience of being given a basket of “things to eat” from a verified source (doctors, dieticians…influencers).
but here’s where the agentic world gets interesting, as ai becomes the new ui, the necessity of privacy preserving agents personalized to a users preferences that can handle the cognitive load to supplement their decisions while proving verified logic on how they come to that conclusion will be key.
feels like a strong intersection opportunity at large here and is a mixture of verification, privacy, agent-assisted decision making, and overall web hygiene
binji (@binji_x)</a> </blockquote>
That exchange splits the problem cleanly. Vitalik is asking for the artifact: what does this system depend on? binji is asking who is supposed to read it without turning every user into a security engineer. Concrete</a>, the programming language I have been writing about, sits between those two questions. It does not solve the whole thing. It builds the part that should never have been prose.

Key takeaways

A trust nutrition label should be a compiler artifact, not vendor prose. Concrete already produces the math-and-code half of one as a byproduct of compiling.</li>
The label has real fields: the capabilities a program uses, every trusted and unsafe boundary, and a per-obligation evidence class (proved, assumed, or trusted) down to a named trusted computing base and the axioms the proofs rest on.</li>
It is verifiable, not asserted. The reports are deterministic and concrete diff</code> fails closed when trust weakens between versions.</li>
It deliberately stops at one half. It says nothing about which actors you trust or for how long, and the verification is partial: the backend and final binary stay trusted. The output is “here is what is proven, by what, and what is not.”</li>
For agents, that means trust should come from the kernel-checked artifact, not the agent’s say-so.</li> </ul> </aside>#</a>Two Different Kinds Of Trust</h2> Vitalik’s label is really asking for two lists. One list is technical: which proofs, components, foreign calls, permissions, and machines does this system rely on? The other is social: which people or institutions must behave honestly, and for how long? Those are not the same problem. Concrete works on the first list. It says nothing deep about incentives, collusion, governance, or whether some actor stays honest for six months. But the technical list is already enough work, and it is the part a compiler can actually produce. #</a>A label generated by the compiler</h2> Concrete is built around a simple habit: when the program makes a claim, the compiler should keep the receipt. A contract, a capability, a trusted boundary, a runtime-safety check: each one becomes something the tool can report on. Compilation should leave behind more than a binary. It should leave behind a record of what the program used and what evidence backs each claim. That ledger has real fields, not slogans. A small slice of it might look like this: function: parse_config capabilities: File trusted_boundaries: - trusted extern fn os_read obligations: O1 array_bounds buffer[i] evidence: proved_by_kernel_decision engine: omega O2 ensures result_is_valid_config evidence: assumed O3 proof link Config.Proofs.parse_config_shape evidence: stale reason: body fingerprint changed tcb: - Concrete checker - Lean kernel - proof attachment and fingerprint machinery - LLVM/backend/runtime/OS/hardware</code></pre> The syntax above is illustrative, but the categories are real: authority, trusted boundary, obligation, evidence class, stale proof, trusted base. The label comes from the program and the proof artifacts. Nobody writes it afterward as a compliance paragraph. Capabilities. Concrete tracks effects as a visible capability vocabulary: the concrete permissions File</code>, Network</code>, Process</code>, Console</code>, Clock</code>, Random</code>, Env</code>, Alloc</code>, and Unsafe</code>, plus a Std</code> macro that expands to the standard set and user-defined aliases that expand at parse time. A function with no annotation is pure. A function that allocates on the heap must say with(Alloc)</code>. A function that touches the network must say with(Network)</code>, and so must everything that transitively calls it. The label cannot under-report, because a program that uses an effect it did not declare does not compile. Trusted boundaries. Every place the program steps outside what the checker can guarantee is marked and locatable: trusted fn</code>, trusted impl</code>, trusted extern fn</code>, and functions or calls carrying with(Unsafe)</code>. You can ask the compiler to enumerate them, and it answers with a list and source spans rather than a shrug. “Does pointer tricks internally” and “can call arbitrary foreign code” are different risks, and they get different markers. Evidence classes. My favorite detail is the absence of a single green checkmark. Every obligation says how it is justified: proved_by_lean</code> for a kernel-checked theorem, proved_by_kernel_decision</code> for a decision procedure, solver_trusted</code> for an external solver result, tested_by_oracle</code>, assumed</code>, trusted</code>, stale</code>, unproven</code>, and more. “This type-checks,” “this is proven,” and “we are trusting the author here” are different statements. Concrete keeps them separate. That is the money changer’s distinction restored to software: the coin you weighed, the coin you did not, and the coin you are choosing to take on faith. None of that is pseudocode, so here is the authority half in real Concrete. A foreign call is a named, audited boundary; a function that touches the console has to say so; and the requirement climbs the call graph on its own: trusted extern fn putchar(c: i32) -> i32; // foreign boundary, audited fn print_int(n: i64) with(Console) { /* ... */ } // needs Console fn greet() with(Console) { print_int(42); } // inherits it from print_int fn main() with(Std) -> Int { greet(); return 0; }</code></pre> Delete with(Console)</code> from greet</code> and the program stops compiling, because greet</code> calls something that needs it. Authority is not a comment that can drift out of date. It is part of the type, rechecked on every edit. #</a>The label carries proofs, not just declarations</h2> A permissions screen says an app can use the network. A software bill of materials says a binary contains some library at some version. Concrete’s label can say something a list of dependencies cannot: that a specific property of a specific function has been mechanically proven, and by what. The mechanism is ordinary design by contract, pointed at verification. A function carries #[requires]</code> and #[ensures]</code> clauses and loop invariants. Each becomes a proof obligation with a stable identifier. A precondition is assumed at the function’s entry and surfaced at every caller, so it cannot be quietly dropped; depending on the active policy, the caller either discharges it or carries an explicit unproven obligation. How it gets discharged is where the marketing version would usually start lying. Concrete is kernel-first. The decision procedures omega</code>, for linear integer arithmetic, and bv_decide</code>, for bitvectors, produce certificates that are checked inside the toolchain, so using them adds no external solver to the trusted base. But the caveats stay visible. bv_decide</code> relies on a compiled LRAT checker, which brings a named tier of native-code trust; it is not pure kernel reduction, and the axiom inventory says so. Concrete can also hand a condition to an external SMT solver. When it does, the result is labeled solver_trusted</code>, and that solver binary becomes part of the trusted base for that obligation. Trust has not vanished. The label tells you which kind of trust you just used. concrete prove</code> is the workflow that makes this usable. It generates a Lean proof workspace for a function, links registered theorems back to their obligations, and supports replay so a proof stays bound to the exact source it was written against. A fingerprint, now a truncated SHA-256 over the function’s structure, detects when the code drifts out from under its proof, and the evidence class flips to stale</code>. The label cannot keep claiming “proven” about a function that has since changed. Here is the proof half in real code, just as small. A bit rotation whose precondition says the shift must stay in range: #[requires(0 <= n && n < 32)] fn rotr(x: u32, n: u32) -> u32 { return (x >> n) | (x << (32 - n)); }</code></pre> That #[requires]</code> is not a comment and not a runtime assert. The compiler turns it into an obligation, pushes it onto every caller, and then reports, one call site at a time, how each call discharges it: call rotr(x, 13) requires 0 <= n && n < 32 -> proved_at_callsite call rotr(x, n) [n=7] requires 0 <= n && n < 32 -> proved_by_kernel_decision (bv_decide) call rotr(x, 40) requires 0 <= n && n < 32 -> failed_at_callsite call rotr(x, k) requires 0 <= n && n < 32 -> unproven_at_callsite</code></pre> Four calls, four honest verdicts. A constant in range folds to proved. A value fixed earlier by a let</code> is handed to a decision procedure and closed with checked evidence. A constant out of range is reported as a violation, and policy can make that a hard failure. An argument the compiler cannot pin down stays unproven</code>, labeled exactly that, never quietly rounded up to fine. The last line is the one that matters most: the label would rather tell you it does not know than tell you a comforting lie. That is the money changer setting a coin aside because the scale was inconclusive, instead of waving it through. Return to the config example. The useful fact is not that the program is “verified.” It is that its File</code> authority is visible, its absence of Network</code> and Alloc</code> authority is checked, its operating-system boundary is named, one bounds obligation is discharged by omega</code>, one semantic parsing claim is only assumed</code>, and one old proof has gone stale</code>. Six facts, six different kinds of trust, none of them collapsed into a checkmark. You learn more from that than from a green “verified” badge, precisely because it shows you where the badge would have been lying. The word “verified” has to stay disciplined. Capabilities and boundaries are enforced or reported by the type system. That is useful, but it is not the same thing as a proof. A contract that reaches proved_by_lean</code> or proved_by_kernel_decision</code> has a machine-checked argument behind it. The label keeps those cases apart so the enforced does not pretend to be proven. #</a>The label includes itself</h2> The best part is that Concrete applies the same suspicion to itself. It prints the trusted computing base: the layers you must trust for any proof to mean anything. The checker and compiler. The Lean kernel. The proof-attachment and fingerprint machinery. The LLVM backend. The runtime, the operating system, the hardware. And the foreign code behind every extern fn</code>. Most systems hide this list. Concrete prints it. Ken Thompson gave the reason in his 1984 Turing Award lecture. You cannot fully trust code you did not write yourself, and the rot can reach all the way down to the compiler: a compiler can carry a backdoor that survives even after its own source is scrubbed clean, by recognizing when it is compiling itself and quietly reinserting the trick. That does not make trust hopeless. It means “trust me, the compiler is clean” is not an answer. You have to name what trusting the compiler commits you to. A compiler that prints its own trusted base and the axioms its proofs stand on is Thompson’s question answered out loud instead of waved away. It even prints the axioms. An axiom-inventory gate runs over every theorem and fails the build on anything undocumented. The mathematical assumptions the proofs are allowed to lean on are named: propext</code>, Classical.choice</code>, Quot.sound</code>, and the flagged native-code trust tier for compiled certificate checking. That is the literal answer to Vitalik’s “what math are you relying on,” extracted automatically rather than asserted in a README. The label can also be regenerated. Same source, same reports. concrete diff</code> compares two versions and flags when trust weakens, when a proof goes stale, when authority escalates, when a boundary erodes. A label you can regenerate and diff is evidence. A label you cannot is marketing. #</a>What it does not cover</h2> Here is the part I would rather say myself than have you catch me on. Concrete does not model the second half of Vitalik’s label at all. There is no notion of actors, incentives, collusion, honesty-until-some-time, or social trust anywhere in it. Its accounting is static, about which layers and which math to trust, not dynamic, about which humans behave well and for how long. The actor-and-time-scale half is a real and separate problem, and it belongs to mechanism design and economics, not to a systems language. The verification is also partial, and the label says so. Proofs attach at the contract and proof-model level, over an intermediate representation and an idealized integer model. The chain from there through the backend down to the final binary is trusted, not verified, and binary correctness sits openly among Concrete’s explicit non-claims. Many obligations are still missing</code> or end in a hand-written Lean proof rather than automatic discharge. So the claim is not “Concrete proves your program correct end to end.” It is smaller and more useful: Concrete proves selected claims over its proof model, then tells you which properties are proven, by what, which trusted base they rely on, and which properties are not proven at all. That is worth more than a green badge. #</a>Who reads the label</h2> binji’s objection is correct and survives even a perfect label. Labels create cognitive load, most people ignore them, and they fall back on a basket curated by someone they trust. This happens with food labels and diets, and it would happen with trust labels too. A manifest nobody reads is decoration. But his answer points at the kind of artifact Concrete produces. He wants agents that carry the cognitive load while showing verified logic for their conclusions. For that to work, the agent needs structured facts it did not invent. Concrete’s label is machine-consumable. It has identifiers, source spans, dependencies, and evidence classes. An agent can read it directly. The cognitive load binji worries about is a problem for a human staring at a wall of facts, not for software filtering those facts against a user’s policy. And Concrete’s strongest conclusions arrive with proofs the kernel already checked, or with explicitly weaker labels when they do not. binji wants the agent to prove the logic behind its recommendation. With Concrete, the load-bearing proof evidence was checked independently of any agent. The agent does not have to be trusted to produce that evidence. It only has to point at evidence that already exists and that it cannot forge without changing the artifact. #</a>Trust should come from the artifact, not the agent</h2> This changes the role of the agent. The usual story makes the agent the thing you must trust: align it, audit it, believe it. Concrete pushes some trust downward into the artifact. The agent’s job is then smaller. It reads facts it cannot easily fake and applies the user’s policy to them. The split is simple. Concrete produces the verified input. The agent applies the user’s preferences. The Lean kernel anchors the strongest evidence. The remaining trusted layers are named instead of hidden. The agent is still not magic, but at least it is reading facts grounded outside itself. One more line so I do not oversell it. Concrete answers the input problem: trustworthy facts about an artifact. It does not answer the alignment problem: whether the agent faithfully serves the user. It can make the agent’s inputs harder to fake. It does not make the agent good. #</a>The ingredients, not just the dish</h2> Everything above labels a program you wrote. But the trust dependency that actually bites is the one you did not write: the parser that quietly starts logging to disk, the hash helper that adds a network call “for telemetry,” the dependency whose proof silently downgrades between versions. Vitalik’s phrase is “a full list of trust dependencies,” and in practice your dependencies are your imports. binji’s basket of ingredients is the import list. Concrete’s design notes take the next step, and I want to be exact: this part is written down as a direction, not yet shipped. The principle is that an import should not silently grant power. It should say what it brings in and what it is forbidden to bring in. So an import carries a ceiling and a floor: import std.parse requires(no File, no Network, no Unsafe) import hmac.compute requires(proved_by_lean) import crypto.compare requires(constant_time, no secret_sink)</code></pre> and a manifest sets a whole-project authority budget: [authority] allowed = ["Alloc"] forbidden = ["File", "Network", "Process", "Unsafe"]</code></pre> Now drift fails closed. If the parser grows File</code> authority, or the hash helper’s evidence downgrades from proved_by_lean</code> to assumed</code>, the build stops and demands an explicit change to the constraint. That is the supply-chain backdoor from the top of this post, caught at compile time instead of explained in a postmortem. Capabilities, contracts, and evidence classes exist today; bounded imports and authority budgets are a design on paper, not a feature you can run. But the direction is the whole point, because it is where the label stops describing one program and starts describing the entire dependency tree, which is the only level at which “a full list of trust dependencies” is actually true. #</a>Labels should be compiler artifacts</h2> Software trust labels should not be vendor prose. They should be compiler artifacts: deterministic, diffable, and backed by machine-checked evidence wherever the strong claims are made. Concrete shows what that looks like for capabilities, contracts, proof obligations, evidence classes, axioms, and trusted boundaries. This is the same argument as a fact-producing compiler</a> and when the compiler is the oracle</a>, pointed at a live conversation elsewhere. The systems-language world and the crypto-trust world are circling the same object from opposite sides. One wants software to emit a verifiable manifest of what it depends on. The other wants a language where that manifest falls out of compilation. Concrete does not solve the honest-actor half, and it does not pretend to. It takes the half that can be mechanized and mechanizes it: the part CI can reject, a reviewer can diff, and an agent can stand on without asking to be believed.



A Proof Is Only as Good as Its Spec
2026-06-06T00:00:00+00:00
I want Ethereum to have more formal verification, not less. That’s why I’m writing this.</p>


Discipline Without Love Optimizes for the Wrong Variable
2026-05-21T00:00:00+00:00
The last year and a half, but particularly the last six months, were incredible but also very very tough. I went through difficult personal problems and had to expand my tolerance for pain to extremes I didn’t know existed. You don’t fight pain by toughening up. You fight it by controlling what you let near you. I left alcohol, lowered my consumption of caffeine to bare minimums, deleted my instagram and removed most of the people I didn’t care about from my life and I doubled down on living with friends family and partners I love.</p>
My father told me multiple times that I have lived multiple lives in one. It’s very likely that he has some responsibility for this because I became obsessed with adventures thanks to Jules Verne when I was a kid. I wanted to explore. I did trips to places and met people that you see only in nightmares. After getting burnt and almost dying multiple times I created LambdaClass</a> and now Ergodic Group</a>. Those near deaths weren’t only pain. Each one was teaching me the same thing: turn this into something that outlasts you, or it was just damage. I’m trying to do the same right now with what happened to me the last few weeks.</p>


Blockspace Forum Cannes - Fede and Justin Drake
2026-04-22T00:00:00+00:00



A Fact-Producing Compiler
2026-04-09T00:00:00+00:00

Series note: this article is part of the Concrete series and responds to Dmitri Sotnikov’s Giving LLMs a Formal Reasoning Engine for Code Analysis</a>.
Related: When the Compiler Is the Oracle</a> and Why Concrete Exists</a>.</p>
</blockquote>
When an AI agent explores a codebase, it usually greps for names, reads a few matches, searches for callers, reads those, and tries to piece together a mental model of the program from text fragments. This works about as well as you would expect. The agent is asking structural questions about a program, things like “can user input reach this SQL query?” or “what changes if I touch this function?”, but the only tool it has is text search.</p>
Yesterday I read Dmitri Sotnikov’s article</a> about giving LLMs a symbolic reasoning engine for code analysis. His tool, Chiasmus</a>, parses source code with tree-sitter (a syntax parser), turns definitions and calls into logic facts, and lets an LLM run graph queries instead of grepping through files. That is a much better interface: the agent asks a structural question and gets a structural answer.</p>
Reading the post gave me a better phrase for part of what we are building with Concrete: a fact-producing compiler</strong>.</p>
Concrete is the systems programming language we are building for programs that need auditability. It compiles code into an executable and into checked statements about what that executable can do.</p>


CommitLLM: How to Verify an LLM Inference
2026-04-02T00:00:00+00:00
You send a prompt to an LLM API. The provider says it ran Llama 70B. Maybe it did. Maybe it served a smaller model to save money, changed the quantization, altered the decode settings, or patched the answer after generation. Today you usually cannot tell. You get text back, an invoice, and a promise.</p>
For casual use, a promise is often enough. For enterprise procurement, regulated systems, benchmark evaluation, or agent workflows making consequential decisions, it is not. If the model behind the answer matters, “trust us” is not a satisfying interface.</p>


What Concrete Makes Worse
2026-03-24T00:00:00+00:00

Series note: this is the tradeoffs entry in the Concrete series.
For the foundation, start with Why Concrete Exists</a>. For the most practical demo, read When the Compiler Is the Oracle</a>.</p>
</blockquote>
The previous articles in this series argued that Concrete’s design constraints are worth it. Explicit capabilities make code auditable. Linear types prevent resource leaks at compile time. No hidden behavior means the compiler can report what your program actually does. I believe all of that. But I have been writing Concrete code for long enough to know where the constraints bite, and I have not been honest enough about that in public.</p>
This article is about what Concrete makes worse. Not in theory, not as an abstract “it’s stricter.” Specific code that is uglier, longer, or more painful to write in Concrete than in Rust or Zig. If you are considering whether these tradeoffs are worth it for your domain, you deserve to see the cost up front.</p>


When the Compiler Is the Oracle
2026-03-20T00:00:00+00:00

Series note: this is the most practical entry point in the Concrete series.
If you want the shorter manifesto first, read Why Concrete Exists</a>. If you want the language reference behind this article, use Concrete Spec</a>.</p>
</blockquote>
I have been building Concrete</a> for a while now. Something happened this week that I did not plan for, and it may end up mattering more than the things I set out to build on purpose.</p>
I let an AI agent improve a Concrete program using only the compiler’s reports as feedback. No profiler. No benchmarks. The agent read what the compiler knew about the program, tried refactorings, checked if the compiler’s answers improved, and kept or reverted. It worked better than I expected. The compiler had made the search space clean enough that the agent did not have to wander through benchmark fog.</p>
That points at why Concrete is useful in the first place. A language that makes authority, allocation, trust boundaries, and proof surface explicit is easier to audit, easier to optimize, and easier to automate against. You do not have to reconstruct the truth from profiler traces, stale docs, and reviewer intuition. The compiler can tell you what is true about the program, and that changes how you build systems software. To explain why, I need to start with what Concrete is and what makes it different.</p>


Writing Your First Proofs in Lean
2026-03-20T00:00:00+00:00
The first article</a> in this series explained the Curry-Howard correspondence: propositions are types, proofs are programs. The second</a> built a tiny theorem prover from scratch in Python. The third</a> embedded the same ideas inside Julia’s type system.</p>
Now we use the real tool. This article takes the exact same theorems you proved by hand in Python and shows them in Lean 4. You will see what changes and what stays the same: the syntax shifts, the logic does not.</p>


Programming a Mini-Lean in Julia's Type System
2026-03-19T12:00:00+00:00
This article is based on Guillermo Angeris’s talk “Programming a (mini-)Lean in Julia’s type system”</a>.</p>
A theorem prover, stripped to its engine, is a small trusted kernel, a type checker, and a boundary between the two.</p>
Guillermo Angeris answers this by live-coding a toy theorem-proving kernel inside Julia that illustrates how Lean works architecturally. The result is a tiny kernel that makes the trust boundary visible: if you accept the kernel, then anything built on top of it has to pass through the type checker.</p>
This is the third article in the Theorem Proving</a> series. The first article</a> covers the Curry-Howard correspondence. The second</a> implements a tiny prover explicitly in Python. This article embeds those same ideas inside a host language’s type system.</p>


Building a Tiny Theorem Prover in Python
2026-03-19T00:00:00+00:00
The first article</a> in this series explained the Curry-Howard correspondence: propositions are types, proofs are programs. That tells you why</em> theorem proving fits so naturally with programming languages. It does not yet tell you what the machine looks like.</p>
A theorem prover, concretely, is smaller than most people expect. A tiny theorem prover is just:</p>

a language for terms</li>
a language for types / propositions</li>
a checker that decides whether a term has a type</li>
a tiny trusted kernel that defines the legal moves</li>
</ol>
This article builds that architecture in plain Python. We are not abusing Python’s own type system. Python is just the implementation language. The prover we build has its own</em> terms, its own</em> propositions, and its own</em> checker.</p>
That distinction matters. The goal here is not to show off host-language cleverness. I want the moving parts to be impossible to miss.</p>


Self-Replicating Programs Emerge from Random Noise
2026-03-18T00:00:00+00:00
Most programmers think Turing completeness is the interesting threshold for a computational system. It gets all the attention. But a lower, stranger threshold matters more for the origin of complex behavior: self-replication.</p>
A recent paper</a> by Agüera y Arcas et al. shows that self-replicating programs spontaneously emerge from soups of random code. No one designs them. No fitness function selects for them. They assemble themselves from noise, take over the soup, and keep evolving. I reproduced the core result in about 300 lines of code.</p>


Propositions Are Types, Proofs Are Programs
2026-03-18T00:00:00+00:00
In the 1930s, Haskell Curry noticed something strange. He was working on combinatory logic, a system for manipulating abstract functions, and he realized that the rules governing his combinators looked identical to the rules of a logical system called intuitionistic propositional logic. It was as if he’d found two different maps of the same territory.</p>
Three decades later, William Howard found the same thing in a richer setting. He showed that the simply typed lambda calculus, the foundation of functional programming, corresponds precisely to natural deduction, a standard system of logical proof. Every type corresponds to a proposition. Every program corresponds to a proof. Every function corresponds to an implication.</p>
This is the Curry-Howard correspondence</strong>: a structural identity between proofs and programs.</p>


Fede's Guide to a Healthier Life
2026-03-13T00:00:00+00:00
When I was young I loved science and engineering. Like most nerds, I thought thinking was the only thing that mattered. Working out seemed like a vanity project, something for people who cared about how they looked and not much else. I didn’t understand the body-mind connection at all. I was a skinny kid who spent all day reading, tinkering with computers, and hanging out with friends. The idea that physical health could affect how well I think would have sounded like nonsense to me.</p>
It took me a long time to figure out how wrong I was.</p>


Can I prove Concrete programs in Lean?
2026-03-12T00:00:00+00:00

Series note: this is the proof-roadmap entry in the Concrete series.
For the language overview, start with Why Concrete Exists</a> and Concrete Spec</a>. For the most practical compiler-report demo, read When the Compiler Is the Oracle</a>.</p>
</blockquote>
I wrote the first version of this essay when proving Concrete</a> programs in Lean was still mostly a plan. The question was simple and a little risky: can we take a function written in Concrete, connect it to something inside the compiler, and prove a real property about it in Lean?</p>
Part of that answer now exists. Not for the whole language, and not for the final binary, but for a real subset. Concrete can take a source contract, turn it into an obligation, attach a Lean-checked proof or a decision-procedure result, and tell you when that evidence no longer matches the code. The important part is not that every claim turns green. It is that the tool refuses to mix up “proved,” “assumed,” “trusted,” and “not done yet.”</p>


Designing a Programming Language for the AI Era
2026-03-11T00:00:00+00:00

Series note: this article assumes the basic Concrete frame is already in place and asks a narrower question about AI-era language adoption.
For the series foundation, read Why Concrete Exists</a>. For the main Rust comparison, read The Rust Effects Debate and Concrete’s Case for a Smaller Language</a>.</p>
</blockquote>
Edgar Luque recently wrote about how AI creates a new adoption barrier for programming languages</a>. His claim is that AI coding assistants need training data, training data only exists for popular languages, and so new languages get bad AI support, which prevents adoption, which in turn prevents training data from accumulating. A self-reinforcing loop that locks in whatever is already dominant.</p>
If you are building a new general-purpose language that competes with Python, Go, or Rust on roughly the same terms, Luque’s analysis is devastating. What makes it worse than previous adoption barriers is that you cannot community-effort your way out of it. The AI training pipelines belong to a handful of companies, and those companies will always prioritize the languages where the most data already exists.</p>
But there is a blind spot in the argument.</p>


The Rust Effects Debate and Concrete's Case for a Smaller Language
2026-03-09T00:00:00+00:00

Series note: this is the main Rust-comparison entry in the Concrete series.
If you are new here, start with Why Concrete Exists</a>. If you want the language reference, use Concrete Spec</a>.</p>
</blockquote>
Yosh Wuyts recently wrote about his “grand vision” for Rust</a>, outlining three directions he thinks the language should pursue: effects, stronger substructural types, and refinement types. The Hacker News thread</a> that followed split predictably: one camp saw a safer, more principled systems language taking shape while the other saw echoes of Scala, C++, and a language that becomes harder to read than the software it is meant to clarify.</p>
Both camps are seeing something real, and I think resolving the tension between them requires something other than adding more features to Rust. That is where Concrete</a> comes in.</p>


Dissolution Without Construction
2026-03-06T00:00:00+00:00
I have been circling the same problem for a while now. Friction produces value. Legibility destroys what it measures. Formation requires lived time. The modern self is dissolving through redundancy. Previous technological shifts gave people decades to adapt, and this one might give them months.</p>
These kept feeling like separate observations. I no longer think they are.</p>
#</a>The Speed Mismatch</h2>
Every major coordination technology in history has dissolved the form of selfhood that preceded it. Writing destroyed oral memory, the printing press destroyed manuscript culture, and institutions dissolved kinship. None of this is new.</p>
What is new is the asymmetry between how fast things dissolve and how fast things grow.</p>
Writing spread slowly. A scribe copied a text, carried it to another city, taught someone to read it. The dissolution of oral memory and the construction of literate thought happened at roughly the same pace, both measured in generations. The printing press was faster, but still slow enough that cultural forms could emerge alongside the destruction. The novel, the diary, the public library, liberal education: these took centuries to stabilize, but centuries were available because print moved at the speed of physical objects.</p>
Algorithmic systems dissolve at computational speed. A recommendation engine can reshape the taste-formation process of millions of people in months. An AI assistant can make inner deliberation feel unnecessary within a single product cycle.</p>
But construction, the formation of new human capacities, new cultural forms, new modes of perception, still happens at biological speed. A person becomes a particular kind of person through years of encounter, revision, failure. A cultural form stabilizes through generations of practice. There is no computational shortcut because the capacity is constituted by the process, not by its output. You cannot compress becoming.</p>
The problem is the gap between dissolution speed and construction speed.</p>
This reframes a conversation that has been stuck for years. One side says previous transitions worked out, so this one will too. They are wrong for a structural reason: previous transitions worked out because dissolution was slow enough for construction to keep pace. That condition no longer holds. The other side says technology is destroying us. They are also wrong, or at least imprecise. Dissolution can be the beginning of construction; every previous transition dissolved something real and produced something new. The issue is speed: dissolution now moves fast enough to make construction impossible.</p>
#</a>Friction as Governor</h2>
Desire depends on resistance. The deeper point is that resistance imposes a pace. The distance between wanting and obtaining is a temporal structure. It gives the person time to become someone who can integrate what they receive. Remove the distance and the person receives before they can absorb.</p>
Friction performs this function at civilizational scale. When the printing press dissolved oral culture, books were expensive. Literacy spread gradually. The oral self did not vanish overnight. It weakened over decades and centuries, and during that time the constructive side, new practices of reading, new institutions, new literary forms, had room to develop. The friction inherent in physical media imposed a speed limit on dissolution, and that speed limit happened to match the speed of human formation.</p>
Friction in taste formation gives a person time to develop the capacity to perceive, beyond a set of preferences. Friction in professional training gives the practitioner time to develop judgment that resists articulation. Friction in deliberation gives the self time to form. Remove it and dissolution outruns construction. The gap opens. Nothing grows where the old capacity was.</p>
#</a>Legibility as Accelerant</h2>
The German forest again. Eighteenth-century foresters replaced diverse, messy woodland with uniform Norway spruce plantations. Yields surged. Then the undergrowth died, the soil degraded, and the forest collapsed. What looked like inefficiency was the system’s life support.</p>
Legibility does something specific to the speed problem. It converts illegible processes into optimizable targets. Once a process is visible, it can be measured. Once measured, optimized. Once optimized, the friction in the original process gets removed as inefficiency. Legibility is the mechanism that identifies friction, and optimization is the mechanism that strips it out. Together they accelerate dissolution.</p>
The self depended on opacity. Taste formed in private. You encountered things by accident, sat with discomfort no algorithm could detect, revised your sensibility through a process invisible to any external system. Professional judgment lived in knowledge that could not be articulated. Inner deliberation happened in a space that was, by definition, not observable from outside.</p>
AI reaches into all of this. It makes taste formation legible through behavioral data. It makes deliberation legible through interaction logs. It makes professional intuition legible through performance metrics. Each act of legibility strips away a layer of friction that was functioning, without anyone noticing, as a speed governor on dissolution.</p>
#</a>The Compounding Problem</h2>
This is the part that worries me most. Dissolution outruns construction and degrades the conditions under which construction is possible.</p>
Formation requires complete cycles: effort, feedback, adjustment, repeated across lived time. Acceleration fragments these cycles. What spreads fastest diverges from what works best. Imitation spreads faster than learning. Every act of dissolution removes some of the friction, opacity, and time that construction requires. The more functions the self loses, the less capacity remains to develop new ones. The process compounds. Dissolution accelerates while the ground for construction erodes.</p>
Someone who has never formed taste through friction is not going to develop whatever post-algorithmic perception might look like. Someone who has never exercised inner deliberation will not develop whatever comes after deliberation. The new capacity, if it exists, will not emerge from a vacuum. It will emerge from people who have developed enough of the old capacity to transcend it, the way literate thought emerged from people who had first mastered oral memory. If dissolution destroys the old capacity before the new one can develop from it, the sequence breaks. What looks like another transition is actually an interruption.</p>
#</a>What Would Have to Be True</h2>
I do not know what comes after the literate self. Nobody in 1450 could have described what the printing press would produce either. But I can describe the conditions under which construction becomes possible.</p>
It would require friction. Not arbitrary difficulty, but the specific resistance that imposes a pace compatible with human formation. It would require opacity. Domains where the slow work of becoming is not legible to optimization systems, where a person can develop without being measured. And it would require time. Actual time. Complete cycles of effort and revision that are not compressed or interrupted.</p>
The current system removes all three. Optimization treats friction as waste. AI treats opacity as a problem to solve. Markets treat slowness as a competitive disadvantage. The incentives point uniformly toward faster dissolution.</p>
Previous transitions produced their own constructive forms because the speed of dissolution left room for them. Print was slow enough that the novel could emerge. Institutional life was gradual enough that liberal education could develop. The printing press did not spontaneously generate the literate self. People built schools, designed curricula, established practices of reading and argument that took centuries to stabilize. That work was deliberate, institutional, and slow, but it was possible because the dissolution it responded to was also slow.</p>
The question I cannot answer is whether anything can grow at biological speed in an environment that has been optimized for computational speed. Whether construction is possible when the conditions for construction are precisely what the system is most efficient at removing.</p>
There is an irony I should not avoid. I build coordination infrastructure for a living. Ethereum clients, cryptographic proof libraries, distributed systems. Tools that accelerate exactly the process this essay describes. And the essay itself is not construction. It is diagnosis. I am genuinely confused by my own position. I see the dissolution clearly enough to write about it. I also build the tools that produce it. I have not resolved this. I am not sure it can be resolved. Naming the speed mismatch does not slow it down. It may even accelerate it by making the problem legible, which is what I argued legibility does: convert things into objects of optimization. I do not know whether writing about dissolution is a form of friction, something that slows the reader down, forces them to sit with discomfort, or a frictionless take on friction, consumed and forgotten at algorithmic speed. I suspect the answer depends on what you do after reading it.</p>


Legibility Kills What It Measures
2026-03-03T00:00:00+00:00
In the 18th century, German foresters invented scientific forestry. They looked at a messy, diverse forest and saw inefficiency. Old trees, young trees, deadwood, underbrush, species with no commercial value. They cleared it all and planted Norway spruce in straight rows, evenly spaced, same age, same species. The forest became legible. You could measure it, manage it, predict its yield with precision.</p>
For one generation, it worked brilliantly. Yields surged. Then the forest began to die. The complex undergrowth had been cycling nutrients, retaining moisture, hosting the insects that pollinated the canopy and the fungi that fed the roots. The foresters had not simplified the forest; they had destroyed the system that kept it alive, preserving only the part they could see.</p>
James Scott tells this story in Seeing Like a State</em> to illustrate a pattern that recurs wherever central authorities impose legibility on complex systems. The pattern is simple: make the illegible legible, optimize what you can now see, and lose what you couldn’t see but depended on.</p>


Finance Is Geometry, and It All Comes Back to Jensen’s Inequality
2026-03-01T00:00:00+00:00
Never cross a river that is on average four feet deep. If the river is eight feet deep in the middle and dry on the sides, the average tells you nothing about whether you will drown. You will drown in the middle, or you won’t. There is no averaging across parallel universes where you both survive and die.</p>
The same asymmetry shows up wherever outcomes compound. Lose 50% of your wealth and you need a 100% gain just to break even, because the loss hits a larger base than the recovery builds from. Going from $100 to $200 and from $200 to $400 are different dollar amounts but the same proportional move: one doubling. Wealth is about ratios and scaling, not absolute differences.</p>
This multiplicative structure has consequences that run deeper than intuition suggests. The mathematics that governs survival in compounding environments was invented 400 years ago to help astronomers multiply large numbers, partially rediscovered in the 18th century to solve a paradox about gambling, formalized again through information theory, and then largely obscured by theories that optimized across hypothetical worlds instead of along a single path through time.</p>
That is the geometric claim in this essay: wealth evolves multiplicatively, while most ordinary intuition is additive. The logarithm is the change of coordinates that lets us move between those two descriptions.</p>
This is the story of why geometry sits at the core of finance, why a single inequality ties the whole picture together, and why reducing variance can be more valuable than increasing returns.</p>
None of the parts are mine. Kelly, Peters, Spitznagel, and Taleb each worked one of them out. My only claim is that they are the same picture, and this essay traces how the pieces fit.</p>


The Tail Hedge Debate: Spitznagel Is Right, AQR Is Answering the Wrong Question
2026-02-26T00:00:00+00:00
Stock markets crash</a>. The S&P 500 price index fell about 57% from October 9, 2007 to March 9, 2009, and about 34% from February 19, 2020 to March 23, 2020. A put option</strong> is a contract that pays you when the market falls below a certain price (the “strike”). If you hold stocks and also hold puts, the puts can offset some of your losses during a crash. The question is whether the cost of buying puts is worth the protection they provide.</p>
There are two sides. AQR Capital Management published “Chasing Your Own Tail (Risk)”</a> (Berger, Nielsen, and Villalon, 2011</a>). They argue that buying puts systematically costs more than it saves. On the other side, Mark Spitznagel at Universa Investments, where Nassim Taleb is scientific advisor, argues that a small put allocation improves long-term returns (Spitznagel, 2021</a>). Universa reported a 3,612% gain in March 2020 (via an investor letter, as reported by Bloomberg).</p>
We tested both claims with our open-source options backtester</a> on 17 years of real SPY options data (2008 to 2025), covering three crashes: the 2008 financial crisis, COVID, and the 2022 bear market.</p>
The version of the trade that survives the data is narrow but real: cheap convexity, sized small, and selected by strike rather than delta</strong>. AQR’s published critique tests neither half of that. They use near-ATM puts (the most expensive form of crash protection per dollar of notional) inside the allocation-reducing framing (selling SPY to fund the puts, surrendering the equity premium that funds everything else). In that configuration deep OTM puts still lose against SPY. Spitznagel’s externally funded overlay flips both choices: deep OTM puts, kept cheap, layered on top of full SPY exposure, sized small. Inside that configuration the strategy shows a positive historical raw gap versus plain SPY across the 2008-2024 window, small at Universa’s described 0.5%/yr scale (~+1.4pp/yr), substantial at the engine’s risk-adjusted sweet spot (+6pp/yr at 3.3%/yr budget with bi-monthly roll). The edge is regime-conditional: it pays in 5-year windows that contain a major drawdown and drags by 2-3pp/yr in windows that don’t.</p>
All headline numbers below are gross of transaction costs, slippage, and taxes. Execution drag at the deep-OTM strikes, Israelov’s strongest surviving objection, is on top of these gross numbers; we return to it in the limitations section.</p>
#</a>What the thesis actually claims</h3>
Spitznagel does not claim that buying OTM puts wins every year, every quarter, or every drawdown. People who read him that way, including (implicitly) AQR’s published critique, are arguing with a strawman. His real claim is about the long run. Put a small slice of capital into deep OTM puts on top of your equity book, hold them through crashes, monetize the convex payoff when it arrives, and over a long enough horizon you compound faster than equity alone. The mechanism is that the rare big payoffs are large enough, and recur often enough, to more than cover the steady premium drag between them. Year-by-year alpha is the wrong test. Long-run compounding is the right one.</p>
On that test, the data says he is right. Across our 17-year SPY sample, every put-overlay budget from 0.5%/yr to 10%/yr beats plain SPY on both annual return and max drawdown. The strike depth Spitznagel describes (deep OTM, not near-ATM) is what makes the trade work. The framing he describes (externally funded, not allocation-reducing) is the half AQR misses. Across every working configuration tested below, the strategy improves max drawdown by 10 to 22 percentage points versus SPY.</p>
Three properties of the data are worth naming up front, so the shape of the result is not mistaken for a flaw. First, the full-period gap is concentrated in two years out of seventeen (2008 and 2020). That is exactly what a tail hedge is built to do: sit dormant for years and deliver convexly when a catastrophe arrives. Second, 7 of 13 rolling 5-year windows are negative. That is what positive expected value looks like when the payoffs are this lumpy. Third, walk-forward validation shows that about half of the in-sample gap survives out-of-sample. That is the haircut to apply when sizing this for a real portfolio, not a refutation of the result.</p>
The wrong reading of all this is that the strategy works only by luck in crash years. The right reading is that the strategy is built to pay in years like those, and over enough time, with realistic crash frequency, the rare large payoffs more than cover the steady small bleeds. That is Spitznagel’s thesis. The data supports it.</p>
Every number below reproduces in one command against the open-source engine. The Code section at the end has the exact invocation.</p>


Detecting Crashes with Fat-Tail Statistics
2026-02-19T00:00:00+00:00
Financial markets don’t follow normal distributions</a>. That is a claim about frequency, not just theory: it tells you how often catastrophic events happen. Under a naive Gaussian model, a crisis on the scale of 2008 lands so deep in the tails that standard risk models treat it as effectively impossible. It happened on a Tuesday.</p>
The problem is that we keep using tools designed for thin-tailed worlds. Value at Risk</strong> (VaR</strong>) models that assume normality. Risk metrics that treat the 2008 crash as an “outlier” rather than a regular feature of financial returns.</p>
I built fatcrash</a>, a Rust+Python toolkit with 15 classical methods, to test whether fat-tail statistical methods can detect crashes before they happen. The performance-critical math (fitting, simulation, all rolling estimators) runs in Rust via PyO3; everything else (data, viz, CLI) is Python.</p>


Twenty Centuries of Financial Data: What 240 Countries and 2,000 Years Reveal
2026-02-12T00:00:00+00:00
In 1252, Florence minted the gold florin. Within decades it became the dominant trade currency of medieval Europe. Merchants in Bruges, Venice, and Constantinople quoted prices against it. By the 1400s, the florin’s dominance had faded, replaced by the Venetian ducat. Then the Spanish real. Then the Dutch guilder. Then sterling. Then the dollar. Each transition involved devaluations, defaults, and crises that ruined anyone holding the wrong currency at the wrong time.</p>
We have data on all of this. Not estimates. Actual recorded exchange rates, starting from 1106. And not just exchange rates: gold and silver prices from 1257, interest rates from 1311, commodity prices from 1260, GDP per capita from the year 1 CE, sovereign debt ratios from 1800, and crisis indices covering two centuries of banking panics, currency collapses, and sovereign defaults.</p>
I assembled forex-centuries</a>, the most comprehensive open-source collection of long-run financial and economic data available. 27 sources, 1,100+ files, ~240 countries, spanning twenty centuries. Exchange rates, precious metals, interest rates, commodity prices, inflation, GDP, real wages, sovereign debt, regime classifications, and real effective exchange rates, all in one repository with an automated build pipeline, weekly CI updates, and reproducible analysis. No other free repository combines this breadth of asset classes across this depth of history. The only comparable product is Global Financial Data</a> (commercial, institutional pricing). The goal: provide the raw material for studying how currencies and financial systems behave over centuries, not decades.</p>


Friction as Luxury: What We Lose When AI Gives Us What We Want
2026-02-05T00:00:00+00:00
#</a>The Last Scarcity</h2>
Most discussions of AGI focus on distribution: who gets access, who profits, who loses their job, who controls the infrastructure. Those are real problems, but they’re not the deepest one.</p>
The deeper problem is what happens to desire. I do not mean ambition in the generic sense. I mean the capacity to want something at a distance, to stay oriented toward something you do not yet have, and to find meaning in the space between reaching and arriving. That capacity is more fragile than we usually admit, and it depends more on friction than most people notice.</p>
#</a>I.</h2>
Economists have a clean model of desire. People have preferences, goods satisfy preferences, welfare rises as more preferences are satisfied. In that framework, a technology that can satisfy almost any preference at negligible cost looks like an obvious good. The only remaining question is who gets access.</p>
That model leaves out something important. Desire has a shape, and that shape depends on certain conditions holding.</p>
When you want something over time, you imagine having it. You plan for it, you make sacrifices toward it. The object accumulates meaning from this process. It gets layered with your effort, your anticipation, your history of reaching. When you finally arrive, you don’t just get the object. You get the object plus everything you invested in wanting it. Those two things can’t be separated.</p>
That is why anticipation is often richer than arrival, why the best albums sometimes need months rather than minutes, and why relationships built through difficulty have a texture that convenient ones often do not. Resistance helps produce the value.</p>
#</a>II.</h2>
When this structure breaks down, the clinical term is anhedonia. But there is a milder and more socially acceptable version of the same pattern. People in this condition can be entertained constantly but rarely feel deeply absorbed. They consume without much appetite. They move from one stimulating thing to the next not because anything is satisfying, but because sitting with incompleteness starts to feel unbearable.</p>
You can already see the shape of it in declining attention spans, in the difficulty of sustaining interest in anything that doesn’t deliver immediate feedback, in people who feel simultaneously overstimulated and bored. They haven’t been deprived, they’ve been saturated.</p>
This doesn’t distribute evenly in society. In environments where discomfort is quickly solved, by money, by services, by endless entertainment, the mind gets less practice holding lack. You can grow up surrounded by abundance and still become poor in one specific way: poor in patience for distance.</p>
Structurally, it starts to resemble addiction: craving breaks away from fulfillment. Neuroscience draws the same line. Kent Berridge’s work separates wanting from liking, and it is the dopaminergic wanting, not the pleasure, that addictive drugs and variable-reward machines exploit. Slot machines and infinite feeds are built around exactly this, unpredictable payoffs on a schedule that trains the nervous system to treat discomfort as a cue for relief and relief as a cue for repetition. A frictionless AI environment could reproduce some of that pattern without chemicals. Boredom, loneliness, uncertainty, and effort all become prompts for instant stimulation. Over time the threshold rises, what once felt absorbing becomes merely adequate, and the rest of life starts to feel slow and underpowered by comparison.</p>
Consumer capitalism produced a weakened version of this. Desire progressively hollowed out by eliminating friction, but with enough friction remaining that the structure didn’t fully collapse. The streaming service still requires you to choose. The algorithm still occasionally surprises you. The simulation of connection is imperfect enough that you sometimes notice it’s a simulation.</p>
#</a>III.</h2>
Imagine a system that can generate, on demand, a novel calibrated to your tastes: the style you find most pleasurable, the level of complexity you find most engaging, the length that matches your current patience. Or music that sounds like what you loved most at nineteen, except new, immediate, and endless. Or a conversation partner who is always interested in what interests you, always available, never distracted, never carrying needs of their own into the exchange.</p>
The output might be genuinely good. The novel could be technically accomplished. The music could actually move you. The conversation could be substantive. The problem is what happens to wanting once the gap collapses to zero.</p>
The capacity to stay oriented toward a distant goal, to defer, to invest, to tolerate incompleteness</a>, atrophies when it is never exercised. Not through a dramatic break, but through disuse. The ability to want things that require time does not vanish all at once. It gets weaker, and the weakening may not even feel like a loss because something pleasant keeps arriving on schedule.</p>
#</a>IV.</h2>
None of this is new. Epictetus drilled his students to want only what was already in their control and to rehearse discomfort on purpose, and Seneca set aside days to live as if poor so that hardship could never be used against him. Fasting in Ramadan, the privations of Lent, and the Rule of Benedict all build scheduled scarcity into a life on the same theory: that meaning runs through resistance rather than around it.</p>
What’s new is the scale. Previous technologies eliminated specific friction but left other friction intact. Every digital environment until now required you to bring something it couldn’t supply: attention, skill, patience.</p>
A genuinely general AI dissolves this last requirement. It can supply the taste, the context, the judgment. You no longer need to bring anything except the desire to receive. And if that desire is itself shaped by the AI, tuned to whatever maintains engagement, then even the wanting has been outsourced.</p>
#</a>V.</h2>
Here is the inversion. Where material abundance is the rule, the things that keep their value are often the ones that resist its logic. Their value is tied to the conditions that make them difficult, not to artificial scarcity.</p>
A handmade object carries the trace of the hands that made it. A wine vintage can’t be accelerated. The waiting isn’t incidental to what the wine is. A community built around a shared difficult practice, painting, rock climbing, chess, building and fielding armies of miniatures, generates bonds that digitally mediated interaction doesn’t replicate, because those bonds are forged in shared difficulty.</p>
These things become valuable not despite being harder than consuming AI output, but partly because of that hardness. When satisfaction is frictionless, friction itself becomes the luxury.</p>
#</a>VI.</h2>
The safety, alignment, and job-displacement debates are all real. But they share a common assumption: that the humans on the other side will still be capable of deciding what to do with what they’ve been given, and that political agency and collective imagination will survive intact.</p>
That assumption is doing a lot of work.</p>
The atrophying of desire is already visible in what weaker technologies have done to culture. What AGI does to human psychology comes before what it does to human politics. A population that has lost the capacity to want things at a distance, to stay oriented toward a difficult future, and to find meaning in effort and incompleteness has lost something essential to self-government.</p>
The scarcity that matters most in a post AGI world won’t be compute or energy. It will be the capacity to want something deeply enough, and for long enough, that the wanting shapes who you are.</p>
If desire is the last scarcity, then slowness, difficulty, and incompleteness are not obstacles to overcome. They are the conditions of a life worth living.</p>


China is trying to commoditize the complement
2026-01-22T00:00:00+00:00
China is trying to win by commoditizing the complement. The strategy is working, though not without friction. This is a structural challenge the West should take seriously instead of dismissing.</p>
For the last two decades, the West exported cognition because it owned the platforms, the cloud, the software distribution, and the talent concentration. If the cognitive engine becomes cheap, portable, and good enough, that asymmetry weakens. A small country can buy or download the same cognitive machinery, then apply it to its own bureaucracy, its own companies, its own language, its own domain problems.</p>
The West has dominated the thinking and services world. Software, finance, media, research, management layers, and the export of expertise. The US is the clearest example. In 2024, US services exports were about 1.1 trillion dollars, the highest on record. The US and the West sell thinking at scale. AI threatens to flatten that advantage because AI turns thinking into infrastructure.</p>
China dominates the atoms world. Industrial capacity, manufacturing throughput, physical supply chains, cost curves. In 2023 China produced about 28 percent of global manufacturing value added.</p>
If you can make the layer next to you cheap and abundant, you drain its pricing power and force value to move somewhere else. In AI, the complement is model access. For a lot of Western companies, the business is still basically gated intelligence sold as an API. China has every incentive to make that layer feel like electricity: available everywhere, cheap, hard to monopolize.</p>
Open weight releases are part of that play: DeepSeek, Qwen, Kimi, and MiniMax are only a few of the Chinese open-source models. Once strong models are common, model access stops being a moat. It becomes a commodity input.</p>
A huge fraction of what we call services is legible work: reading, writing, coding, summarizing, translating, drafting, answering, generating variations, searching a space of options. That layer is now replicable and it is getting local. Apple is publishing technical reports about on-device foundation models, including aggressive quantization aimed at making serious inference run on consumer hardware. When strong models run on a laptop, countries stop importing thinking as a service. They import weights, or they distill, fine-tune, and deploy inside their own borders.</p>
The commodity play is working, but it is not frictionless. China faces real constraints, and they shape how far the strategy can go.</p>
Capital controls limit how freely Chinese companies can operate globally. The state can redirect investment at a scale nobody else can match, but centralized allocation tends to overshoot. Solar panel overcapacity, steel oversupply, and the EV price war all follow the same pattern: massive subsidized buildout that ends up compressing margins for everyone, including the Chinese firms themselves.</p>
Top talent still flows toward open research environments. By MacroPolo’s Global AI Talent Tracker, China is the single largest source of the world’s top-tier AI researchers, yet a large share of them end up doing that work in the United States. Tightening political control over universities and private firms can speed up execution on defined goals, but it makes the open-ended, high-risk research that produces real breakthroughs harder to sustain.</p>
Predictability matters for long-term innovation, and the last few years dented it. The abrupt suspension of Ant Group’s record $34 billion IPO in November 2020, the 2021 crackdowns that erased the for-profit tutoring sector overnight and froze new game approvals for months, and Didi’s forced retreat from US markets after its 2021 listing all sent the same signal: any company can become a target without warning. Foreign firms recalibrated their exposure and some domestic founders turned cautious. Centralized coordination buys speed, but it also shrinks the appetite for bets that do not match current state priorities.</p>
The West still has one advantage that is hard to replicate: it is where most of the world’s ambitious talent wants to live, work, and build. It is a compound effect of open institutions, freedom of movement, and decades of accumulated trust. As long as that holds, the West keeps attracting the talent and the capital that turn ideas into new industries.</p>
None of these constraints cancel out the commodity play. They set its ceiling. China can drive the price of model access toward zero faster than anyone, but the open-ended research and the institutional trust that turn a cheap commodity into new industries are much harder to subsidize into existence.</p>
China stays strong in atoms because it already has the scale advantage. The West still leads in areas that require deep institutions and long accumulated competence, frontier research and high trust services in particular. But AI compresses the services premium by making a large portion of cognition cheap and replicable. That is why open models matter. They attack the margin structure of the thinking economy.</p>
If you sell intelligence, this is bad news. If you own distribution, hardware, data, or a workflow people cannot easily leave, you survive. If you own atoms and you get thinking for free, you get a scary combination, because the services premium that sustained Western economic leadership for decades can be undercut by a player with industrial dominance and access to the same cognitive tools.</p>


Fede's Guide to Type Systems: From Generics to Dependent Types
2026-01-01T00:00:00+00:00
Every type error you’ve ever cursed at was a bug caught before production. Type systems reject nonsense at compile time so you don’t discover it at 3 AM. But they vary wildly in what they can express and what guarantees they provide.</p>


Why Concrete Exists
2025-12-26T00:00:00+00:00

This is the foundation piece for the Concrete series.
If you want the most practical demonstration first, start with When the Compiler Is the Oracle</a>. If you want the living language reference, use Concrete Spec</a>.</p>
</blockquote>
Systems programming has a recurring problem. We want to write code close to the machine, but we also want to make strong claims about what that code does. Does it allocate? Does it touch the network? Does it leak resources? Can it be audited without tracing twenty helper functions and three layers of library convention?</p>
Most languages answer those questions indirectly. You read the implementation. You profile. You infer from style. You trust unsafe</code> blocks, docs, and review discipline. Even in strong languages, much of what matters about a program lives outside the type system.</p>
Concrete exists because I think that is the wrong place to stop.</p>
Concrete is a systems language built around a single organizing principle: every important property the compiler can know about a program should be explicit enough for humans and machines to act on directly</strong>.</p>


The Death of the Inner Self
2025-12-23T00:00:00+00:00
The core argument is simple: many features of human life that appear stable and natural are historically produced. As society accelerates, a number of these features begin to lose their function and their permanence. I believe consciousness as we know it is one of them.</p>
#</a>Individuality as technology</h2>
Life is organized around information that replicates under constraint. Computation generalizes this biological logic. It allows selection and optimization to occur faster and at larger scales by externalizing memory, comparison, and feedback. Problems that once required internal deliberation can be solved through external processes that test, filter, and iterate possibilities.</p>
Capital pushes this logic further. It reorganizes social life around continuous feedback, price signals, and competitive selection. As these forces compound, individuality starts to look less like a foundation and more like an interface that emerged to solve earlier coordination problems.</p>
Capital behaves as an impersonal intelligence oriented toward speed, abstraction, and self-optimization. As cognition, decision-making, and coordination migrate into automated systems, the inner self loses its structural role. Over time, many assumptions we take for granted are worn down by this acceleration. Individuality and consciousness appear increasingly exposed to this process.</p>
#</a>The construction we cannot see</h2>
Fish do not realize they live in water. The medium that sustains them is so constant that it disappears from perception. Some of the most important structures are overlooked for the same reason. Individuality and consciousness belong to that category.</p>
We tend to treat individuality and consciousness as self-evident facts, as if humans have always experienced themselves as bounded selves with an inner voice, a private mental space, and a continuous narrative identity. Because this experience feels natural, it is assumed to be timeless. Serious thinkers have argued it is not. Julian Jaynes pointed out that the heroes of the Iliad show almost no inner mental space, hearing the voices of gods where we would hear our own deliberation. Charles Taylor traced how the modern “buffered self,” sealed inside its own mind, was assembled over centuries out of religious and philosophical practice, displacing an older “porous self” open to forces from outside. For most of human history people did not describe themselves as individuals in the modern sense. Decisions were not understood as outcomes of inner deliberation, and agency was not located inside a private interior self. Action was organized through rituals, traditions, kinship, and prescribed roles. Meaning arrived from outside the person rather than from introspection. In many societies outside the Western trajectory, this structure remains largely intact.</p>
The idea of a you inside your head observing your own thoughts is therefore a learned construction. It depends on language, habits, metaphors, and social practices that had to be developed and stabilized over time. Lev Vygotsky argued that inner speech is not innate but internalized social speech: children first talk to others, then to themselves aloud, then silently, until the dialogue goes underground and starts to feel like the private voice of a self. Narrative memory, moral self-examination, and the sense of authorship over action emerged the same way, as cultural achievements layered on top of older biological processes.</p>
Modern societies actively reproduce this configuration. From early childhood, people are trained to understand themselves as autonomous units with opinions, preferences, goals, and an inner life that belongs only to them. The training is so pervasive that it becomes invisible. Other ways of being human recede from view, even though many have existed and some still persist.</p>
#</a>The weakening of the conditions</h2>
The conditions that once made individuality functional are weakening. Earlier systems relied on human subjects to think, decide, judge, and take responsibility. Cognition and coordination were constrained by human minds. Individuality emerged as a solution: a stable self enabled long-term planning, moral accounting, and institutional continuity.</p>
Earlier societies coordinated without modern consciousness. Contemporary systems increasingly coordinate without modern selves. Decision-making proceeds without inner deliberation. Meaning is delivered through incentives, metrics, and feedback loops.</p>
At the cultural level, individuality remains constantly invoked. People are urged to be themselves, express themselves, optimize themselves. Yet the channels for expression arrive pre-shaped, quantified, and monetized. What appears as selfhood increasingly takes the form of managed performance within narrow bounds.</p>
#</a>Replacement by degrees</h2>
The modern self does not collapse in a single moment. It is replaced function by function, each substitution small enough to go unnoticed.</p>
Taste was once formed through a slow, private process: encountering things by accident, sitting with discomfort, learning to love what initially resisted you. Algorithmic recommendation compresses this into a profile that updates in real time. The system knows what you will like before you do. The inner process of forming a preference, the hesitation, the revision, the gradual shaping of sensibility, loses its purpose when an external system performs it faster and with better accuracy. What remains looks like taste but functions as consumption.</p>
Judgment follows a similar path. In organizations that once depended on accumulated experience, performance metrics now determine what counts as competent work. The slow formation of professional intuition, the kind that takes years to develop and resists easy articulation, gets flattened against quarterly targets. This is Goodhart’s law turned structural: once a measure becomes the target it stops measuring what it was meant to, and here the target gradually replaces the faculty it was only ever a proxy for. When the metric becomes the institution’s memory of what the work is for, the judgment it was meant to approximate quietly disappears. People still show up. They optimize what is measured. The rest erodes.</p>
Inner deliberation faces the same pressure from a different direction. When an AI assistant can draft your emails, plan your week, summarize your reading, and suggest your next decision, the internal process of thinking through a problem starts to feel unnecessary, not wrong exactly, just slow. The assistant never tells you to stop thinking; it just makes thinking feel like friction in a system that rewards speed. Over time, the habit of sustained internal reflection weakens for the same reason any unused capacity weakens: through disuse.</p>
Each of these substitutions is individually reasonable. Each solves a real problem. Taken together, they describe a pattern where the functions that once required a self are gradually absorbed by systems that do not.</p>
#</a>What is at stake</h2>
The modern self once felt inevitable because it solved concrete problems. It enabled abstraction, continuity, and responsibility at scale. Its future usefulness is far less certain.</p>
The self depends on performing certain functions, and when those functions migrate outward, the self weakens not through suppression but through redundancy.</p>
Individuality was real. It produced philosophy, law, science, art, and institutions that reshaped the world. The question is whether it will remain functional as the systems around it absorb more of what it used to do. A coordination technology that no longer coordinates does not persist on sentimentality alone.</p>
The self will not simply switch off. But the conditions that produced it are changing, and what comes next may look different enough that the word “individuality” stops pointing at anything we would recognize. Whether that transition is a loss, a transformation, or simply the next phase of the same process that produced the self in the first place is not something that can be settled in advance. But it should be named clearly, because what cannot be seen clearly cannot be preserved deliberately.</p>


Notes on permanence, time, and ergodicity
2025-12-15T00:00:00+00:00
Some systems improve the longer you stay with them. Repetition sharpens execution, experience carries forward, and judgment builds on itself.</p>
At Hermès, a leather worker trains for two years before touching a bag. One artisan makes one bag start to finish, every stitch by hand, fifteen to twenty-four hours of work per piece. This is the opposite of speed at all costs</a>. It is also one of the most successful luxury companies in the world. The constraint is part of what the customer is paying for.</p>
The broader culture moves in the other direction. Cycles shorten. Signals multiply. Decision horizons shrink. A lot of institutions keep moving while quietly losing the judgment they once had. They stay busy, but they stop getting better. Copying outruns learning.</p>
In that environment, endurance tells you something. If a system keeps working under stress for a long time, its structure probably matches reality better than its competitors’. The internet did not flatten everything. It made it easier to see who had substance and who was living off distribution.</p>
#</a>Two forms of time</h2>
Time operates in human systems in two fundamentally different ways.</p>
Measured time is divisible and uniform: schedules, deadlines, accounting periods, discount rates. It can be allocated, optimized, and exchanged. Most planning systems live here. They assume value can be judged apart from history.</p>
Lived time works differently. It accumulates. Learning, memory, and judgment develop through it, and each cycle changes the next one. Anything that depends on formation happens here. Snapshots miss the point because the value is in what compounds.</p>
In 2001, Boeing moved its headquarters from Seattle to Chicago. The stated reason was to position the company closer to “Wall Street and governments.” Engineers who understood the planes were physically separated from executives who understood the spreadsheets. Over the next two decades, Boeing spent more than $40 billion on stock buybacks while cutting capital expenditure to half of Airbus’s rate. Harry Stonecipher, who took over as CEO, said he wanted Boeing “run like a business rather than a great engineering firm.” The 737 MAX, designed to avoid the cost of pilot retraining, killed 346 people. This is what happens when lived time is forced into measured time.</p>
Berkshire Hathaway made the opposite bet. Buffett has refused quarterly earnings guidance since 1996. Shareholders are told to judge the business over decades, not quarters. The result is six decades of compounding judgment, the longest sustained record in American corporate history. Same markets, different use of time.</p>
When lived time gets forced into measured time, formation breaks down. Standards do not settle. Judgment does not compound. You only find out what a system really is if you leave it alone long enough to show you.</p>
#</a>Formation under constraint</h2>
Excellence comes from sustained practice under the right constraints. Errors have to be survivable. People need room to adjust without every bad iteration becoming fatal. Judgment improves when experience carries over from one attempt to the next.</p>
At Pixar, every film is terrible for years before it is good. Ed Catmull describes the process as taking movies “from suck to not-suck.” The mechanism is the Braintrust: a group of fellow directors and storytellers who meet every few months to review each film in production. The key detail is that the Braintrust has no authority. The director is not required to take a single suggestion. That keeps candor high without turning feedback into bureaucracy.</p>
Most studios kill projects after one bad screening. Pixar treats bad screenings as information, not verdicts. The difference is structure, not talent. Formation takes time, and the Braintrust protects that time by separating honest feedback from the power to cancel.</p>
#</a>Four domains</h2>
We built Ergodic Group</a> around the idea that enduring organizations work across four domains: mathematics, code, culture, and craft. Most live mostly in one. The edge comes from connecting them.</p>
Mathematics sets the structure and the constraints. Code turns that structure into action and tests it against reality. Culture lets intent survive changes in personnel. Craft brings the whole thing back to materials, tolerances, and physical consequences.</p>
SpaceX shows how these domains work on each other. The math: a technique called lossless convexification lets an onboard computer solve fuel-optimal landing trajectories in real time, computing the exact moment to fire the engines so velocity hits zero at touchdown. The code: autonomous guidance software recomputes trajectories during descent, adjusting for wind and sensor readings, which makes landings on ocean platforms possible. The culture: failures are instrumented, not hidden. Between 2013 and 2016, SpaceX crashed booster after booster, and each crash produced telemetry that led to a specific fix. Hydraulic fluid ran out, so they added more. A throttle valve stuck, so they redesigned it. The craft: when carbon fiber layup produced wrinkles at roughly $200 per kilogram, SpaceX switched Starship to stainless steel at roughly $3 per kilogram. Steel gets stronger at cryogenic temperatures, handles far more heat, and opened reentry profiles that carbon fiber could not. A materials decision changed the vehicle, the software, and the math.</p>
Learning compounds when these domains stay connected.</p>
#</a>Ergodicity as a filter</h2>
Ergodicity describes a situation where repetition improves the usual outcome because learning carries over from one round to the next.</p>
Claude Shannon spent fifteen years at Bell Labs before publishing “A Mathematical Theory of Communication” in 1948. He was not being graded on quarterly output. Bell Labs gave researchers something modern organizations rarely give anyone: enough uninterrupted time to get to the bottom of a problem. That setup produced the transistor, information theory, Unix, the laser, and cellular telephony. The transistor came not from a brainstorm but from people with different specialties working near each other for years.</p>
When AT&T was broken up in 1984, that model disappeared with it. No later technology company has reproduced the same output. The institution itself held the judgment, and that judgment did not survive disassembly.</p>
As acceleration intensifies, most sectors get noisier and more fragile. Coordination gets harder. Institutional memory thins out. Advantages that looked durable turn out to depend on a few people, a few habits, or a distribution edge that disappears. Infrastructure and culture last longer because they are environments people operate inside, not products to be sold. When learning carries forward, time starts working in your favor.</p>
#</a>Operation</h2>
In 1984, GM and Toyota opened a joint factory in Fremont, California called NUMMI. Toyota sent over four hundred trainers from Japan for months of side-by-side work with American employees. Absenteeism dropped from twenty percent to two percent. Defect rates fell to the lowest in the United States.</p>
GM tried to export the lessons. A vice president told employees to “take a picture of every square inch” of NUMMI and replicate it at other plants. It failed everywhere. The visible process looked the same. The results did not. The missing piece was judgment, and judgment does not travel well as a memo</a>. Toyota had not built a checklist. It had built a way of working.</p>
The NUMMI lesson reaches past any specific practice. The value was never in the visible process; it lay in the judgment that accumulates when people have time to learn, when the links between domains stay intact, and when repetition actually improves the work.</p>


The new financial backend of the world
2025-12-09T00:00:00+00:00
By Federico Carrone and Roberto Catalan</strong></p>
The previous article</a> argued that the internet left a gap in institutional infrastructure: it moved information but not ownership. Ethereum fills that gap by embedding ownership, transfer, and enforcement into shared software. Financial institutions today spend enormous resources on authorization, accounting, reconciliation, and compliance. Ethereum substitutes a portion of that apparatus with a programmable execution environment and cryptographic enforcement. This article looks at the specific economic mechanisms through which that substitution works.</p>
#</a>Three frictions</h2>
Some economists describe transaction costs through three frictions: triangulation, transfer and trust. Triangulation concerns how economic actors identify each other and agree on terms. Transfer concerns how value moves between them. Trust concerns the enforcement of obligations. Traditional financial architecture manages these frictions through scale, proprietary systems, and coordination among intermediaries.</p>
Ethereum lowers all three, and the numbers are now hard to wave away. Take transfer: stablecoins, dollar tokens that live on the chain, settled about $27.6 trillion in 2024, more than Visa and Mastercard combined, with roughly 95 percent of that volume on Ethereum and its rollups. Most of that figure is exchange and bot flow rather than honest payments, so discount it heavily, but the payments slice is real and growing, and a dollar can move between two strangers in different countries in seconds for cents, with no chain of correspondent banks in between. Take trust: a loan on Aave never asks who you are. The collateral rules sit in a contract that liquidates the position automatically when it crosses a threshold, and anyone can read that contract before they sign.</p>
None of this removes institutions; it changes which parts of the stack they have to build. A startup offering dollar accounts in Lagos or Buenos Aires no longer builds settlement, custody, and clearing. It inherits them the way a web startup inherits TCP/IP, and spends its effort on product and distribution. That lets firms serve markets incumbents wave off as too small or too complex.</p>
Having a single global ledger also changes operational dynamics. Many institutions operate multiple databases that require frequent reconciliation and remain vulnerable to error. Ethereum maintains a continuously updated and replicated record that cannot be amended retroactively. Redundancy and recoverability become default properties rather than costly internal functions.</p>
Security follows the same pattern. Instead of defending a central database, Ethereum distributes verification among many independent actors. Altering history requires coordination at scale and becomes prohibitively expensive. Confidence arises from system design rather than institutional promises.</p>
#</a>New financial services and global reach</h2>
You can see this in what people actually do with it. In Argentina, where the peso lost more than half its value against the dollar in 2023, ordinary savers hold USDT the way they once held paper dollars in a drawer, except this version moves. Remittances that cost the global average of around 6 percent through a money-transfer operator move as stablecoins for a fraction of that. And the instruments are climbing the respectability ladder: tokenized US Treasury funds grew from about $140 million in early 2024 to roughly $8 billion by late 2025, led by BlackRock’s BUIDL at around $2.8 billion, with Franklin Templeton running a government money-market fund whose shareholder records live on seven different chains.</p>
The pattern underneath is always the same. Work that used to live inside an organization, reconciling ledgers, proving balances, enforcing the terms of a deal, moves into shared software that every participant can read. The firm is left with the parts that actually differentiate it, product and distribution, and it grows by winning users rather than by rebuilding plumbing its competitors already have.</p>
The impact is most visible in markets with fragile financial systems. In economies with unstable currencies or slow payment networks, Ethereum provides immediate functional gains. In developed markets the benefits appear incremental but accumulate as more instruments and processes become programmable.</p>
#</a>Institutional transformation and long term dynamics</h2>
Many financial instruments are heterogeneous. Corporate debt is a clear example. Terms differ by maturity, coupon, covenants, collateral, and risk. Trading depends on bilateral negotiation and intermediaries who maintain records and enforce obligations. Ethereum can represent these instruments digitally, track ownership, and execute terms automatically. Contracts retain their specificity, while administration becomes standardized and interoperable.</p>
The boundary between what firms must build and what software can enforce is moving. Regulation and legal systems remain central, but the institutions sitting on top of them look different when settlement, custody, and enforcement are handled by shared infrastructure instead of proprietary systems.</p>
Ethereum already functions as an alternative financial rail. Multiple independently developed clients, substantial real world usage, an active research community, and a commitment to openness and verification set it apart from other blockchain networks.</p>
#</a>Conclusion</h2>
Ethereum converts core financial frictions into software functions, and that changes the economics of building and operating financial services. Institutions become lighter, focused on product and distribution rather than internal infrastructure.</p>
Technological transitions begin in niches where incumbents do not meet demand. As systems mature, costs fall and broader adoption becomes feasible. Ethereum followed this path. It began with internet native communities, expanded across emerging markets where users lacked reliable financial tools, and is now positioned to upgrade mainstream markets by making financial companies easier to create and operate.</p>
Software is becoming the organizing principle of financial infrastructure. Ethereum makes that concrete. Regulation and institutional adaptation will shape how far it goes, but the economic incentives already point toward systems that are open, verifiable, and resilient.</p>
#</a>Further reading</h2>

DefiLlama. Stablecoin market cap and supply</a>.</li>
The Defiant (2025). Stablecoins Process $27.6 Trillion in 2024, Surpassing Visa, With 95% Settled on Ethereum</a>.</li>
Yellow.com (2025). Tokenized U.S. Treasuries Hit $7.3B in 2025</a>.</li>
</ul>


The missing institution of the Internet
2025-12-02T00:00:00+00:00
By Federico Carrone and Roberto Catalan</strong></p>
The internet made copying and sending information almost free. It did not answer the harder question: who owns something online, who can transfer it, and who enforces the answer when two people disagree?</p>
For a long time the practical answer was simple: the platform decides. Facebook decides what happens to your page. Apple decides what ships in its store. Stripe, Visa, a bank, or a court decides whether a payment or claim settles. That worked well enough to build the web we have, but it left the economic layer of the internet sitting on private terms of service and local legal systems.</p>
Ethereum is interesting because it tries to put some of that missing institutional layer directly into software: records, rules, transfers, collateral, and enforcement backed by economic incentives and cryptographic verification.</p>
#</a>Technology, Culture and Institutional Design</h2>
Some inventions help a person do more. Fire, agriculture, medicine, computing. Others help strangers do things together. Property rights, contracts, markets, companies, courts. Both matter. A new tool creates capacity; an institution decides who can use that capacity, who gets paid, and what happens when someone cheats.</p>
#</a>Property Rights and Markets as Social Technologies</h2>
People invest when they believe they can keep what they build. Property rights give that assurance by saying who owns what, who can use it, and who can be excluded. Markets sit on top of those rights. Prices only work because there is some legal and social machinery underneath them.</p>
None of this is natural. It was built through law, politics, habit, and a lot of compromise. The global economy of the twentieth century ran on that machinery: neutral jurisdictions, corporate shells, bank rails, accounting rules, courts, and contracts that let people who did not know each other trade anyway.</p>
#</a>The Missing Architecture of Digital Ownership</h2>
The internet lowered the cost of communication across borders, but it never created a neutral way to define and enforce claims on digital assets. Offline, ownership goes through courts and states. Online, if there is no shared settlement layer, ownership falls back to whoever runs the server or whichever jurisdiction can reach the dispute.</p>
Platforms filled the hole. They gave us identity, search, feeds, stores, payments, messaging, distribution. In exchange, they kept the switch. You can build inside their walls, accumulate users, even become valuable, but your rights are only as strong as the platform’s current policy and willingness to keep you around.</p>
Zynga is the clean example. It built a huge games business on Facebook and briefly became worth more than Electronic Arts. Then Facebook changed policies and economics, and the ground moved. Zynga owned its games, but not the environment those games depended on. That is the normal platform bargain: you can own the shop and still rent the street.</p>
Platform economies give you participation without full control.</p>
#</a>Ethereum as an Institutional Experiment</h2>
Ethereum is one answer to that missing layer. It gives people a way to create, transfer, and enforce digital assets without asking a company or a state to be the final record keeper. The rules live in code. The record is shared. The network checks itself.</p>
In ordinary software, the operator is sovereign. If a company runs the database, the company can change the database. Ethereum makes that harder by spreading execution across many machines that run the same code and agree on the result. Misbehavior is punished economically. Trust is still there, but some of it moves from a private operator to a public protocol.</p>
Some institutional work then becomes protocol work. Auditors check records; Ethereum makes the record public and replayable. Escrow agents hold assets; smart contracts can hold and release collateral according to rules. Courts enforce agreements after the fact; a contract on-chain can make some violations impossible in the first place. Law still matters. The claim is only that some of the work law and intermediaries used to do can move into shared infrastructure.</p>
Ignore the ideology for a moment and look at the structure: no single operator can quietly rewrite the ledger or block a transaction for everyone.</p>
#</a>The Emergence of a Digital Financial System</h2>
Ethereum started with people building for themselves: wallets, tokens, exchanges, experiments, strange coordination games. Then the financial use case stopped being theoretical.</p>
The most consequential development has been the rise of stablecoins</a>, dollar tokens backed by reserves of cash and short-term Treasuries. Their combined market value passed $300 billion in 2025, dominated by Tether’s USDT (about $176 billion) and Circle’s USDC (about $74 billion), most of it issued on Ethereum. The flows are no longer a rounding error: stablecoins settled around $27.6 trillion in 2024, edging past Visa and Mastercard combined, roughly 95 percent of it on Ethereum, though much of that volume is exchange and bot activity rather than genuine payments.</p>
Stablecoins are boring in the way important infrastructure is boring: dollars that move globally, settle continuously, and plug into software. Once those dollars exist on-chain, lending markets, collateral systems, automated exchanges, and payment flows can be built around them.</p>
The difference from traditional finance is practical. The system is global by default. Services share standards. Exit is fast. Risk is visible on-chain, even if users still misunderstand it.</p>
Compare that to countries like Argentina</a>, where interoperability between banks and fintech wallets, something as trivial as scanning a QR code, can become a regulatory fight. Incumbents use their position to avoid connecting. On Ethereum, interoperability is the default because the assets and contracts share the same base layer. From a phone, a user can receive dollars, swap them, lend them, borrow against collateral, or move them elsewhere. That is why adoption is strongest where ordinary intermediation is expensive, slow, or hard to trust.</p>
#</a>Implications</h2>
Remittances, trade finance, private credit, tokenized Treasuries, collateral markets: all of these are being pulled toward blockchain rails for the same reason. They are record-heavy, settlement-heavy, and full of intermediaries whose job is mostly to verify and move claims.</p>
Plenty can still go wrong. Regulatory uncertainty, operational risk and rough user experience all constrain adoption. Scaling throughput without giving up decentralization remains an open engineering problem. Software vulnerabilities and governance failures have already cost real money. In 2016 a bug in The DAO drained about $60 million of ether and split the community into Ethereum and Ethereum Classic over whether to claw it back. Cross-chain bridges have fared worse: the Ronin bridge lost about $625 million to North Korea’s Lazarus group in March 2022. More is coming.</p>
The serious claim is narrower than the hype. Some financial intermediation can probably run cheaper and more transparently on shared rails. Whether it becomes mainstream depends on regulation, incumbents, user experience, and whether the engineering keeps improving.</p>
#</a>Artificial Intelligence and Coordination</h2>
AI makes production cheaper. It does not decide who owns the output, who can use it, who gets paid, or who is liable when something goes wrong.</p>
That is why AI and Ethereum feel complementary rather than competitive. AI expands what people and agents can produce. Ethereum gives some of that activity a place to settle: accounts, payments, collateral, permissions, and contracts that do not depend on one platform operator. If agents are going to trade, hire, escrow, license, and pay each other, they will need rails where the rules are legible and settlement is not owned by a single company.</p>
#</a>Conclusion</h2>
The internet lowered the cost of transmitting information but left digital ownership in the hands of whoever runs the platform. Ethereum tries to move part of that ownership and enforcement layer into public infrastructure.</p>
It may become core infrastructure. It may remain a specialized tool. Regulators, incumbents, and engineering limits will decide a lot of that. But it has already shown something important: digital property does not have to mean “an entry in someone else’s database.”</p>
The internet built an economy before it built its own institutions. Ethereum is one attempt to build them after the fact.</p>
#</a>Further reading</h2>

DefiLlama. Stablecoin market cap and supply</a>.</li>
The Defiant (2025). Stablecoins Process $27.6 Trillion in 2024, Surpassing Visa, With 95% Settled on Ethereum</a>.</li>
CoinDesk (2022). Axie Infinity’s Ronin Network Suffers $625M Exploit</a>.</li>
</ul>


Next 10 Years of Ethereum
2025-11-15T00:00:00+00:00



Thank You to the Argentine Senate
2025-11-12T00:00:00+00:00
On 12 November 2025 I received a Mención de Honor al Valor Científico from the Comisión de Ciencia y Tecnología of the Argentine Senate. Thank you.</p>


Ethereum's Native Rollup Roadmap with Justin Drake
2025-10-01T00:00:00+00:00



Crypto doctrine
2025-09-25T00:00:00+00:00
#</a>Crypto and the accelerated and chaotic 21st Century</h1>
Crypto has been most useful where trust is weakest. In practice, it has found product-market fit in two places:</p>

In countries where inflation, capital controls, or censorship are ordinary constraints, crypto gives people and companies tools they actually need.</li>
In internet-native communities, crypto provides a financial layer that lets people coordinate, speculate, and build markets at a scale the web did not support before.</li>
</ul>
People that don’t live in a developing country or that didn’t grow up with the internet have enormous difficulties understanding crypto because they don’t have skin in its game. They believe crypto doesn’t have any “real” use case or that is not serious enough. They are right. The thing is that we are living in a world that’s becoming more absurd.</p>
Memes do not only make you laugh anymore, memes are now winning elections.</p>
These use cases will grow with time and probably new ones will be found. The world is becoming more chaotic and more divided each day. Crypto benefits from that kind of environment because it reduces the number of places where trust has to be taken on faith.</p>
One of crypto’s prime advantages is that it kills many of the middlemen and allows us to coordinate</a> even in the harshest environments. Trust assumptions fall because more of the system is enforced by incentives, compilers, distributed systems, and cryptography. That does not remove politics or disagreement; it just narrows the set of things people need to argue about.</p>
Most of us are internet natives. We grew up on IRC, 4chan, Reddit, Hacker News, Twitter, Bitcoin, and Ethereum, and we also have roots in unstable countries. We are the Fremen of crypto, raised in a harsh environment. We know what chaotic societies feel like from the inside, and we know what it takes to build inside them. At the same time, we are builders who like working at the frontier of engineering and scientific change.</p>
Open source and decentralization are not just philosophical preferences for crypto. They are practical conditions for the ecosystem to work. Building in the open, helping other people onboard, and creating systems larger than the original project are part of how crypto survives long term. This can look irrational if you assume the only goal is short-term extraction. It is more legible if you assume the goal is to help a new financial and coordination layer persist.</p>
Our main objective is to help these new internet highways get built in sustainable ways. Economic sustainability matters, but so do resilience, openness, and the ability to resist the usual drift toward centralization. Centralization is almost always easier in the short run. If pure money were the only objective, there would be simpler ways to make it. We treat money as a tool, not the final point.</p>
Whether crypto is useful is already settled. It is, in places most critics never look. The open question is whether the systems being built today will be resilient enough to matter when the next round of chaos arrives.</p>


Markets as Reflexive Fixed Points
2025-06-14T00:00:00+00:00
Markets are the cleanest laboratory for reflexive dynamics.</p>
Prices are not determined by beliefs alone. Cash flows, constraints, inventories, regulation, leverage, and flows all matter. But beliefs about prices become trades, trades become prices, and prices update beliefs.</p>
That loop is the object.</p>
Biology reaches critical-like organization through selection, feedback, and development over evolutionary time. Markets can generate critical-like statistics much faster, because the feedback loop is explicit. Participants model the market while participating in the market. Their models are not external descriptions. They are part of the thing being described.</p>
The careful claim is not that every market is literally sitting at a physical critical point. The claim is narrower and stronger: reflexivity, leverage, liquidity, imitation, and coarse-graining can make markets behave like systems near criticality. They produce fat tails, volatility clustering, correlated cascades, hysteresis, and path dependence.</p>
#</a>The Minimum Vocabulary</h2>
Reflexivity</strong> means the description of the system affects the system being described. In markets, a belief about prices can become an order, and the order can move prices.</p>
An order book</strong> is the current set of resting bids and offers. It is a local picture of liquidity: how much can be bought or sold before the price has to move.</p>
Liquidity</strong> means the ability to trade without moving the price too much. Low liquidity makes feedback stronger because a given flow moves the state more.</p>
Leverage</strong> means controlling a position larger than one’s own capital. It amplifies gains, losses, forced selling, and contagion.</p>
Margin</strong> is collateral required to keep a leveraged position open. If losses reduce equity below the required level, positions must be reduced or liquidated.</p>
Volatility clustering</strong> means large moves tend to be followed by large moves, and quiet periods tend to be followed by quiet periods. This is one reason market risk is not well described by independent Gaussian shocks.</p>
Coarse-graining</strong> means replacing fine detail with larger-scale summaries. In markets, that can mean aggregating trades over longer time windows.</p>
A tail exponent</strong> describes how quickly rare large events disappear. For a survival tail:</p>
$$P(|R|>x)\sim Cx^{-\alpha},$$</p>
smaller $\alpha$ means a heavier tail.</p>
Hysteresis</strong> means the path matters. A system can move from one regime to another and fail to return along the same route when the original parameter is reversed.</p>
#</a>The State Space Of A Market</h2>
A market is not just a price series. Price is the visible coordinate, but it is not the whole state.</p>
A minimal state vector might include:</p>
$$x_t=(p_t,b_t,L_t,Q_t,\sigma_t,C_t),$$</p>
where:</p>

$p_t$ is price,</li>
$b_t$ is the distribution of beliefs or forecasts,</li>
$L_t$ is leverage,</li>
$Q_t$ is liquidity depth,</li>
$\sigma_t$ is perceived volatility,</li>
$C_t$ is cross-asset correlation.</li>
</ol>
This is still a caricature. Real markets include inventories, funding constraints, market makers, options dealers, passive flows, regulation, news, taxes, settlement, and institutional mandates. But even this reduced state is enough to show why markets are nonlinear.</p>
The variables do not move independently. If price falls, volatility estimates rise. If volatility rises, risk limits tighten. If risk limits tighten, positions are cut. If positions are cut into low liquidity, price falls again. That is a feedback loop, not a sequence of independent shocks.</p>
So the market update has the same form as every dynamical system in the series:</p>
$$x_{t+1}=F(x_t,\eta_t),$$</p>
but now part of $x_t$ is made of beliefs about $F$ itself. That is the extra reflexive ingredient.</p>
#</a>What Is A Belief Variable?</h2>
“Belief” sounds psychological, but the market version can be made concrete.</p>
A belief is any rule that maps information into desired position:</p>
$$\text{information}\longrightarrow\text{forecast}\longrightarrow\text{order}.$$</p>
A discretionary investor may express this as a story: “earnings will accelerate, so the stock is cheap.” A trend follower may express it as a rule: “if twelve-month momentum is positive, buy.” A market maker may express it as an inventory-adjusted quote. A risk model may express it as a volatility target. A passive index fund may express almost no forecast, but it still follows a rule that converts flows into trades.</p>
At the population level, beliefs are not one number. They are a distribution of strategies:</p>
$$b_t=\text{distribution of forecasts, constraints, and trading rules at time }t.$$</p>
That distribution is part of the market state because it determines future flow. If enough capital uses the same model, the model becomes a force. If the model stops working, capital leaves it, and the distribution changes.</p>
#</a>Reflexivity As A Fixed-Point Problem</h2>
Participants model the market. Their models generate trades. The aggregate of trades sets prices. Realized prices update the models.</p>
At the level of the strategy ecosystem:</p>
$$\text{distribution of models}=F(\text{distribution of models}).$$</p>
This is Keynes’ beauty contest in fixed-point language. The market is not only asking what an asset is worth. It is asking what others believe others will believe it is worth.</p>
Soros called this reflexivity. In the language of this series, reflexivity is representational closure made institutional. A market is a system where descriptions of the system feed back into the system’s state.</p>
This does not mean markets are irrational noise. It means the object being priced is partly shaped by the act of pricing. That is why the fixed point can be unstable, non-unique, or unreachable by simple dynamics.</p>
The mechanism is concrete:</p>

participants model the market,</li>
models generate trades,</li>
trades move prices,</li>
prices update the models,</li>
profitable models attract capital,</li>
capital changes the market that made the models profitable.</li>
</ol>
At that point the meta-level is financialized. There is not only a market in assets; there is a market in models of the market. Hedge funds, factor portfolios, risk models, execution algorithms, and passive rules all compete to become the dominant description. The distribution of models is determined by outcomes, and outcomes are determined by the distribution of models.</p>
That is why the fixed-point equation belongs at the level of the strategy ecosystem:</p>
$$\text{distribution of strategies}=F(\text{distribution of strategies}).$$</p>
In equilibrium language, this is related to Nash. In Keynes’ language, it is the beauty contest. In Soros’ language, it is reflexivity. In the language of the previous essay</a>, it is representational closure: the system contains models of itself that help produce itself.</p>
This is where the first two essays</a> pay off. A reflexive fixed point is not automatically an attractor. The logistic fixed point $x^\star=1-1/r$ keeps existing past $r=3$, but it stops attracting: nearby states orbit it instead of settling into it. The market’s belief-fixed-point can behave the same way. Leverage, crowding, and the speed of feedback play the role of control parameters. Past a threshold, the fixed point can lose stability. Prices then do not converge to it. They may oscillate, trend, overshoot, or jump between regimes.</p>
This is not a proof that every reflexive market is critical. It is a mechanism. Reflexivity supplies feedback. Leverage amplifies feedback. Liquidity constraints make feedback nonlinear. When those forces interact across many scales of capital and time, the system can produce the empirical signatures associated with criticality: clustered volatility, fat tails, drawdowns of many sizes, and sudden correlation spikes.</p>
A bubble is not simply “people being wrong.” It is a reflexive regime in which price increases validate the beliefs that caused buying, attracting more capital into the same belief. A crash is not simply “the truth arriving.” It is often the bounded system forcing positions back through liquidity constraints, margin calls, and risk limits.</p>
A minimal reflexive model has two state variables: price $p_t$ and belief $b_t$.</p>
$$p_{t+1}=F(p_t,b_t),$$</p>
$$b_{t+1}=G(b_t,p_{t+1}).$$</p>
A non-reflexive model would treat beliefs as external or fixed. A reflexive model lets beliefs and prices update each other. A local equilibrium is a fixed point:</p>
$$p^\star=F(p^\star,b^\star),\qquad b^\star=G(b^\star,p^\star).$$</p>
Stability is then a Jacobian question. Linearize the two-dimensional map around $(p^\star,b^\star)$. If the eigenvalues stay inside the unit circle, perturbations decay. If an eigenvalue crosses the unit circle, the market can move into oscillation, trend amplification, or regime change. This is the same local-stability logic as the logistic map, but the state now includes beliefs about the state.</p>
To make this concrete, use the simplest linearized form:</p>
$$\begin{pmatrix} p_{t+1} \\ b_{t+1} \end{pmatrix}
=
\begin{pmatrix} a & c \\ d & e \end{pmatrix}
\begin{pmatrix} p_t \\ b_t \end{pmatrix}.$$</div>
The coefficient $c$ says beliefs move prices. The coefficient $d$ says prices update beliefs. Reflexivity is the product $cd$. If $cd$ is small, the loop damps. If $cd$ is large, the loop amplifies. The eigenvalues of the matrix tell you which regime you are in.</p>
This is also where two famous worldviews turn out to be the same local stability question. Reflexivity has a sign. When the loop is self-correcting, a belief that pushes the price too high invites the trades that pull it back, the eigenvalues sit inside the unit circle, and prices track fundamentals: that is the efficient-market picture. When the loop is self-reinforcing, a belief that pushes the price up invites trades that validate the belief and push it further, an eigenvalue crosses the unit circle, and you get bubbles and crashes: that is Soros’s reflexivity. They are not rival equations for how markets work. They are different regimes of the same two-variable map. The product $cd$ measures the direct feedback loop, but the stability threshold is the spectral radius of the whole Jacobian, the same threshold</a> from the first essay, now deciding whether a market self-corrects or runs away. The disagreement is empirical, about which regime a given market is in and when, not about the mathematics.</p>
One caveat, stated plainly so the move is not oversold: this “same map, two regimes” reading is the interpretive lens this series brings, not a treaty Fama and Soros would both sign. Fama largely rejects reflexivity as too imprecise to test; Soros regards the efficient-market hypothesis as a damaging idealization. The reconciliation is what the dynamical-systems framing adds, not a neutral account each camp would endorse. What the framing does earn is a sharper question: instead of asking which side is right in general, ask which regime a given market is in, and what is pushing its loop gain across the line.</p>
This is the same mathematics as a two-dimensional feedback controller. Finance adds a nasty feature: the coefficients themselves change during stress. Liquidity $Q_t$ falls, leverage constraints bind, and volatility estimates rise. So the matrix that looked stable in calm conditions can become unstable exactly when it matters.</p>
#</a>Simulation: Reflexive Feedback</h3>