Why scale and search keep beating our cleverest tricks. · Source

Our cleverest hand-built tricks keep losing to raw scale.

For seventy years, one pattern keeps repeating. We hand-build our hard-won knowledge into a system — and it wins, for a while. Then a simpler method with more compute behind it walks in and beats it, by a mile. Like a toppled champion: the favorite's careful, hand-tuned play falls to something that just looked further ahead. The lesson stings — and it keeps coming true.

Building in what we know feels smart. It quietly caps us.

The tempting move is always the same: pour everything we know into the system — our rules, our features, our hand-drawn shortcuts. And it helps, right now. Like a drawer of cookie cutters: instant if the shape is one you already own — useless the moment the world hands you a new one. Hand-built knowledge is a fixed set of shapes. It can never make one you didn't carve.

Underneath it all, compute keeps doubling — for free.

C(t) = C_0 \cdot 2^{\,t/\tau}

Here's the engine nobody has to earn. Raw computing power keeps doubling every couple of years, on its own. Like folding paper: each fold is the same trivial act, yet the thickness doubles, and doubles — a few dozen folds would reach the sky. In plain words: every span τ, the compute you can throw at a problem is twice what it was. Bet against a method riding that curve, and you bet against arithmetic.

One method turns raw compute straight into foresight.

N \approx b^{\,d}

The first method that just eats compute needs no human know-how. Search looks ahead: from here, every move; from each, every reply; and on. Like cracks across ice: one split forks into two, each into two more — reach deeper, the branches multiply. In plain words: with b moves at each step and d steps deep, the futures number b times itself d times. More compute buys more depth — and depth is foresight.

The other method that eats compute: just keep learning.

E(C) \approx E_\infty + \left(\dfrac{C_0}{C}\right)^{\alpha}

The second general method doesn't look ahead — it learns. Feed it more data and more compute and its error keeps sliding down a smooth curve, with no hard ceiling like the hand-built kind. Like honing a blade: every pass on the whetstone leaves a keener edge — each adding a little less, all of it creeping toward the sharpest the steel allows. In plain words: double the compute and the gap to that floor shrinks by the same fraction — again and again, but never to zero.

Fixed ceiling, rising line: the crossing is guaranteed.

C^{*} = C_0\left(E_{\text{prior}} - E_\infty\right)^{-1/\alpha}

Now put them side by side. The hand-built method is stuck: its knowledge is fixed, so more compute barely helps — a ceiling it can't pass. The general method's error keeps falling. Like a tide over a seawall: the hand-stacked wall holds the early waves, but the sea itself keeps rising, and there is always a moment it slides over the top. In plain words: there's a compute level past which the learner wins — and since compute doubles on its own, we always reach it.

Don't build in what we know. Build in how to find it.

Here's the real lesson, and it isn't "humans are useless." It's subtler: stop pouring in what we know, and build in how to discover. Encode the search and the learning — the methods that turn compute into knowledge — not the knowledge itself. Like keeping a sourdough starter, not buying a loaf: the loaf feeds you once; the living starter makes bread for the rest of your life. Build the thing that keeps finding.

🌱 If the winning methods only find, what's left to teach?

For seventy years we tried to hand our knowledge to the machine. The lesson keeps answering: don't hand it knowledge — hand it a way to find knowledge. So we built the gate, and pointed at the field. If every method that wins is one that discovers rather than one we fill, maybe our deepest work was never the answers — it was teaching a thing how to look, and knowing when to step back. So what is left to teach a mind that learns to find everything for itself?