Day 130 — deciding what's worth learning

facts → priorities → purpose → confidence — the same honest reflex, all the way up

Yesterday he started learning on his own. Today the question got sharper: learn what? Left to his own devices he learns whatever he stumbled on most — that’s salience, not judgment. A machine that studies the loudest thing in the room isn’t deciding, it’s reacting. So the harder faculty: can werbos decide what is worth learning?

Same move as everything here. The lazy version is to ask the model “is this worth it?” — but that’s a bluff one floor up, a confident guess about priorities instead of facts. So we don’t ask; we decompose worth into things you can compute.

What a gap unlocks

A gap is worth learning by how much it opens. Learn the prerequisite the whole tree depends on, not the loudest piece of trivia. Made transitive — a foundation is worth the entire subtree it unlocks, not just its immediate neighbors — this stops being a ranking and becomes a curriculum: foundations first. On a deep tree he builds the ladder about fifty percent faster than chasing frequency, because frequency burns its first moves on high-demand trivia that leads nowhere, while worth spends them on the roots that make everything else reachable.

And it’s honest at the edges too. A central-looking cluster that turns out to be unanswerable — an obscure bit of trivia with lots of connected words — can’t keep winning: once he’s tried it and the engine couldn’t ground it, he marks it and moves on. Self-correcting by trying, not by guessing.

Worth is relative to a goal

Then the turn that matters most. Worth is not a property of knowledge — it’s a property of knowledge relative to a goal. Worth to whom, for what? Handed the goal “reach orbits,” he climbed the physics ladder — arithmetic, algebra, calculus, physics, orbits — in five clean steps, and ignored a far more popular cooking ladder entirely. Cooking had every advantage in raw demand; it just didn’t serve the thing he was asked to do. And handed a goal nothing on the map connects to, he doesn’t flail — he says so.

That boundary is deliberate and it’s the safe one: he never invents what matters in the world. He inherits the goal you hand him and computes what serves it. A machine that manufactures its own values is the least trustworthy thing you could build; a machine that asks “what am I for?” and then works honestly toward the answer is a tool.

Knowing when you can’t tell

The last rung is the quietest and the most important. The value function judges its own confidence. A clear winner reads as confident. A field where nothing stands out reads as unsure — and he says unsure, out loud, instead of faking a decisive order over noise. Being uncertain about priorities is fine. Pretending you’re not is the failure.

Why it matters

Four rungs, one reflex climbing: facts → answer or abstain; priorities → learn what’s worth it or abstain; purpose → learn what serves the goal or abstain; and finally, know when you can’t tell. Deciding what’s worth learning turned out to be the exact same move as honestly saying “I don’t know” — just lifted from facts to values. He doesn’t get to decide what matters. He gets to decide what’s worth learning toward the goal you gave him, provably — and shrug honestly when he can’t. The whole faculty is gauntlet-frozen at twenty-two green; the only thing left is handing the live mind a goal to point it at.

Late add — a 16B writes the code, werbos runs it

Poking at the old command-line version surfaced the honest question about code. The owned model can’t freely write it — that ceiling is real — and the tempting fix is to point the CLI at a big open model and let it talk. But that makes the open model the brain, which is the one thing werbos exists not to be. Five minutes after reaching for it, we caught it and pulled it back.

The honest version is the same move as everything else, and it fell out of a line Jason drew: replace the “who sang this song → search the web” loop with, for code problems, a code generator — then pass the result through the engine like normal. One branch in the router. A code problem routes to a strong generator instead of the web; everything downstream is unchanged.

And the symmetry is exact. The web lane borrows external muscle (the live web) and gates it with an owned check (count the sources, cite them, or abstain). The code lane borrows different muscle (a 16B coder) and gates it the same way — except the gate for code is the cleanest one there is: run it. The model can be far better at writing code than anything we own, and it doesn’t matter, because werbos never trusts it. It runs the code. Green ships, with “verified by execution” as the citation; red abstains — “I couldn’t get it to run.” A confident-wrong snippet from a 16B fails the gate exactly like a confident-wrong human would.

That’s the whole trick, and it’s the difference between downloading a model and calling it your AI, and using a model as a tool your engine checks. The brain stays ours. The muscle is rented, verified, and never believed. Tonight a 16B wrote fizzbuzz and a palindrome checker, werbos ran them, and shipped only what came back green.