Keep what works.
Throw the rest.
Essays on building durable systems in an age of disposable answers. And the tools that come out of writing them. The point was never the destination. It was always the becoming.
Here for Trinity? Skip straight to the product ↓because what you build you can’t foresee, so you steer by what’s already going wrong
because errors surface continuously, so correction has to run continuously, not wait for permission
Build the affordance, not the policy.
because a loop that runs that often can’t live on willpower, so the correction has to live in the structure
because structure only holds if the right path is also the cheap one, or the loop routes around it
Anchor fast proxies to slow truths.
because the cheap path is only worth taking if the signal it follows stays tied to the truth it stands for, or you optimize a number into a lie
Build for endurance, not speed.
because a proxy anchored today drifts tomorrow, so the coupling has to hold long after the sprint that made it
Oscillate locally, stabilize globally.
because a system built only to hold preserves what works but can’t find what works better, so bounded chambers explore while the rest exploits what has held: one world moving against another held still
Ask what survived, not what changed.
because the chambers only pay off if you know what to keep, so among surprises take only the ones that shrink the book, and keep only what held in every chamber at once
Measure the shape, not the assumptions.
because the anchor only holds if you check it against what happened, and you are the easiest person to fool, so meter before you interpret
Judge with veracity, not ferocity.
because an honest measurement is wasted on a motivated verdict, so the judgment has to be calibrated, not loud
Free your attention to learn fast, not to slow down.
because once the judgment is trustworthy, the loop runs itself, which was the purpose all along: not to slow you, but to set you free
Trinity Local
Most ideas on this site ended up in a single product. This is the first one.
Ask all three. Keep what works.
You cannot tell which of your agent's confident outputs is wrong, and one model cannot tell you, because its checker shares its generator's blind spots. Send one prompt to Claude, ChatGPT, and Gemini in parallel. A chairman shows you what they agreed on and, more to the point, where they split — the cross-provider read no single model can give you, however good it gets, because none of them can see the others. That split is a measured risk signal, and Trinity acts on it: where your change has a test it runs the test, and two labs that did not write it give the diff a second read. Two answers per change — stop, or read it yourself. Trinity never tells you to skip reading. Free and local, on the subscriptions you already pay for. No API key. Your transcripts never leave your machine.
Just an MCP server inside the CLIs you already use: Claude Code, Codex and agy (Cursor too). No new app, no cloud, no API key. Your transcripts from all of them stay on your machine, in one place you own, so switching subscriptions moves nothing off your disk.
Two moments, day one. Before you commit to a plan, Claude, Codex and Gemini answer it independently and the chairman hands you one decision, what would change it, and exactly where they split. Before you call a change done, Trinity runs your tests, and the labs that did not write it read the diff as a second opinion. Trinity tells your agent when each moment comes up.
Then it gets sharper. Your lens builds in the background
from the transcripts already on your disk: how you rephrase, judge, and
decide. Councils work without it, and the chairman reads it once it's
ready. On the disagreements your own later work settles,
trust shows which model you kept siding with, at
model-and-version fidelity: a benchmark no lab can publish, because only
the layer above the labs sees your judgment across all three.
- Put a plan in front of all three labs, day one
- See exactly where they split, and what would settle it
- Check a change with your own tests before you call it done
- Transcripts from every CLI, kept on your disk
- A lens built from those transcripts, read by the chairman
- Which model your later work sided with, on your own disagreements
Install is one line. It installs Trinity and registers it in every CLI it finds: Claude Code, Codex, agy. One is enough to start. The "where they split" payoff needs two.
The principles, and where each was earned
Each essay below is case history for a line of the principles above.
The Architecture of Becoming
The future is not a prediction problem. It is a design problem. The Builder's Trinity (grit, curiosity, simplicity), and why the goal was never a flawless foundation but a distributed system of error correction. You are one of the unfolding's authors.
Utopia is a Mechanism
Democracy, science, free speech. Not values, algorithms. Distributed error correction. Knowledge isn't a settled state of being right. It's the dynamic process of being less wrong. Utopia is not a destination. It's a mechanism.
The AI-Native Way
The Bitter Lesson, restated for builders. Rules and logic you write in code don't matter long-term. The only durable strategy is a systems-level data pipeline: find the edges, save the failures, finetune, repeat. That loop is what gets better over time.
Design the Affordance
It's a design problem, not a prediction problem. Behavior is not goal-driven. It's a structural affordance. The motivation industry is 70 years of symptom management. Six moves replace the entire incentive layer. Pull, don't push, from the steady state: remove the resistance so the right path is the cheapest one.
The Gravity of Becoming
Difficulty was never the point. Depth was. Time to Wow: under five seconds. Time to Mastery: infinity. In a world of flawless AI outputs, imperfection becomes proof of humanity. Pull, don't push, from the threshold: make the value of the deep path perceptible in the first five seconds.
It's a Coupling Problem
Short-term versus long-term was never a weighting problem. It's a coupling problem: whether your fast, cheap proxy still moves the slow, expensive truth it stands in for. Don't weight the future. Build the loop whose only job is to check.
The Architecture of Endurance
Scale is not a size. It is a shape. Endurance is the same shape, repeated, with a wall around every copy. Separation of powers, in the language of machines, is a refusal to pass the gradient.
The Architecture of Discovery
Control without variation preserves what works but can't discover what works better. Chaos without control discovers but destroys attribution. Bounded chambers explore while the rest holds still. And a 4,400-line deletion shows the demotion half of the loop.
Causality Is an Invariance
Pearl's ladder was never a staircase. Intervention and invariance are the same object at two prices, counterfactuals are replays against a frozen mechanism, and the only anomaly worth your attention is the one that promises to shrink the model.
You Are the Specimen
You must not fool yourself — and you are the easiest person to fool. A stronger wall built by the same hands that want through it just raises the cleverness of the breach. Measure the shape, meter it, pre-register the floor. And register the registrations.
Everyone's a Critic
Creation went to zero. Criticism went to zero right behind it. Same mechanism, one beat later. The scarce asset isn't the critic. It's calibration: proof of whose judgment still tracks the truth. Everyone's a critic. Almost no one's a verifier.
Free You More
Two things can learn what you like: a recording and an apprentice. The recording needs you forever. The apprentice frees you. Don't build the thing that needs you less. Build the thing that frees you more.