Part 3: Making Values Computable

How to author your AI Utility Function — one weight at a time.

I ended Part 2 with a promise: that we’d stop admiring the idea and go build it. That we’d take a sentence like “safer matters more than faster” and turn it into something a machine can actually optimize. So, let’s roll up our sleeves. This is the part where the philosophy has to become arithmetic — or it was never real to begin with.

And I want to start with the most over-nodded-at sentence in all of AI.

“AI Should Reflect Human Values.” Great — Tell Me the Weights.

You’ve heard it in every keynote, every op-ed, every panel: AI should reflect human values. Everyone nods. Nobody moves. Because, as is usually said, it’s a wish, not an instruction — there is nothing in it that a machine could do one bit differently tomorrow morning.

Here’s the move I’ve learned to make. When someone tells me AI should reflect human values, I answer with four words:

Great — tell me the weights…and only you can set them.

That’s the whole job. To reflect a value is to decide how much it counts against every other value in the room. Safety matters — of course it does. More than travel time? By how much? Two-to-one? Six-to-one? The instant you answer that, something quiet and profound happens: a value stops being a bumper sticker and becomes a decision a machine can carry. That’s what it means to make a value computable. Not to reduce it to a number — to commit to it enough to weigh it.

A value you can’t weigh against another isn’t actionable yet. It’s an aspiration, not an objective.

Let’s Author One — Highway 30, in Numbers

Back to the road. In Part 2, my wife and I chose Highway 30 over I-80 because, for us, the calmer, safer road was worth more than the saved minutes. I put rough numbers on it: safety 60%, travel time 30%, scenery 10%. Those three weights are the objective. Everything the machine does after that is just faithful execution.

Here’s how they actually go to work. A route isn’t scored on one thing; it’s scored on a handful of features at once — road conditions, route safety, scenic value, miles, travel time. The engine takes each candidate route, measures it against every feature, multiplies each measure by the weight I assigned to it, and sums the results. Plainly:

A route’s score = (how safe it is × 0.60) + (how fast it is × 0.30) + (how scenic it is × 0.10).

That’s the whole trick. Highway 30 doesn’t win because it’s shorter — it isn’t. It wins because once safety carries 60% of the vote, its calmer miles outscore I-80’s faster ones. Same map. Same live traffic. Same causal engine from Part 1. The only new thing in the system is a set of weights that didn’t exist until I decided them. I didn’t make the machine smarter. I told it what smart was for.

The weights are the objective. Everything downstream is the machine doing exactly what you told it — with a rigor you’ll never match, toward a finish line you drew.

Now Watch What the Weights Do

Here’s where it gets fun, and where the whole idea earns its keep. Leave the map alone. Leave the engine alone. Just change the weights — and watch the recommendation move.

Picture three drivers on the exact same Des Moines–to–Cedar Rapids stretch. The one in a hurry sets travel time to 0.80 and road conditions to 0.20 — and the engine hands back I-80. Fastest. The one carrying precious cargo puts route safety at 0.50 and spreads the rest across road conditions, a little scenery, and miles — and the engine reroutes to Highway 30. Safest. The one on a Saturday with nowhere to be loads scenery and historic sites up to 0.80 — and the engine threads a route past the Vermeer windmill in Pella and the Amana Colonies. Most interesting.

Three drivers. One map. One engine. Three different “best” routes — because “best” was never a property of the road. It was a property of the person, made legible to the machine as a column of numbers, each adding up to 1.0. That’s the picture I want you to hold: not a smarter GPS, but the same GPS, willing to call three different routes “best” depending on whose values it was handed.

No — We Did Not Just Solve Human Values With Math

Making values computable does not mean we reduced human values to arithmetic, or that a spreadsheet now knows what a good life looks like. What we did is make your values actionable by forcing the one question that abstraction always skips — how much does this count, next to that?

The machine can then compute against your answer with total rigor. But it never gets to choose the answer. Weighting is a human act. The math just makes the human act operative.

Keep the line clean, and you keep the whole series honest: the machine computes the objective; it never picks it. Blur that line, and you’ve handed your steering wheel to something that was only ever built to hold it, not to decide where to point it.

Making values computable doesn’t hand your values to the machine. It hands the machine your decision — and keeps the deciding yours.

Where Values Meet Mathematics

In The AI-Human Edge, I described the AI Utility Function as the place where values meet mathematics. Everything we’ve done in this article is simply showing how that happens: by making your values computable. Your values become explicit weights, and those weights become the objective the machine optimizes.

And because it’s numbers now, it’s tunable — which is the quiet gift most people miss. When your priorities shift, you don’t retrain a model or argue with an app. You re-weight. Kids in the back seat tonight? Nudge safety up. Ice in the forecast? Up again. Running late to a flight you cannot miss? Let travel time take the wheel for one trip. The objective isn’t carved in stone the day you write it. It’s a living document you author, and re-author, as often as your life changes — which is to say, constantly.

You don’t retrain the machine when your priorities change. You re-weight. The objective is yours to revise, any day you like.

The Weights Are Yours. The Engine Beneath Them Is the Next Climb.

Step back and look at the whole road we’ve traveled. Part 1 was everything the machine can do — the climb from prediction to intervention to causal reasoning. Part 2 was the one thing only you can do — name the objective. And Part 3 is what naming it actually requires: making it computable, authoring the weights, tuning them as you go.

That completes the human’s half of the bargain. What’s left is the machine’s half — and it’s the real frontier. Giving a system a causal backbone deep enough to reason from your authored weights to the exact right move, and to show its work while it does, is a genuinely harder thing than optimizing a weighted sum. It’s the fourth rung — what Mark Stouse calls Causal Engineering — and it’s most of what I’m building toward now. But that’s a bigger canvas than a blog can hold, and I’m saving it for one that can do it justice.

For now, sit with the part that’s already in your hands. The machine will carry any objective you give it with a rigor no human can match. It will never once care which objective it is. That’s not the machine’s failure — it’s the space deliberately left for you. Making your values computable is simply how you fill it: how you turn “this is what I care about, and this is how much” into a future a machine can help you actually reach.

The smartest engine in the world is still waiting on the one input only you can author. Now you know how to write it down.