Sitting Down Without an Interpreter — Where One Piece of Judgment Becomes a Rule

In March 2026 we ran "The Foundation Is Already There". The gist was this — "you can build a tool too" sounds like being told to start from bare ground, but it is exactly the opposite: eight tenths of a tool is judgment, and that judgment is already in the hands of the person who would most benefit from building it. What is missing is one axis, the screen.

The best paragraph in that piece was not a figure of speech but a warning.

What the foreman called "this sound" becomes "in the event of abnormal noise" in the document, and thirty years of ear evaporates in between.

That is how the eight tenths get lost. Judgment wears away in transit. It passes through a requirements document and a developer's reading, and the nuance of "well, it's a bit different in this case" disappears.

So the piece's real claim was not "screens are easy to make". It was whether judgment can sit down without an interpreter. That is not a question of difficulty but of route.

Back then the route was stated only in prose. Here we confirm it against things that actually run.

A farmer's piece of judgment — seven lines

Building the greenhouse control sample, we put a growing rule like this.

Rule(
  name: 'vent above 26C',
  whenKind: 'temperature',
  above: 26.0,
  thenKind: 'vent',
  setTo: 80.0,
  elseSetTo: 0.0,
),

Seven lines. And what matters is what these seven lines do not say.

They do not say which sensor. They do not say which relay. Not one character of a model number. Only the kind of value read and the kind of thing moved. So swap the thermometer for another company's and these seven lines survive intact — we actually swapped it, changing a Celsius sensor for a Fahrenheit model and adding a CO2 sensor and a valve, and the rules did not change by one character.

A: vent above 26C: 26.5 -> v1=80.0     (TH-100, Celsius, 3 nodes)
B: vent above 26C: 26.3 -> v1=80.0     (FX-200, Fahrenheit, 5 nodes)
   server code: unchanged   rules: unchanged   rebuild: none

Where the original wrote "a piece of judgment becomes a definition without an interpreter and sits down on the screen", we can now put how many lines that piece is and what it survives.

(The whole greenhouse chain is in Swap the Sensor, the Control Stays.)

The foreman's checklist — blocked from a single change

There is one more thing that took the original's warning head on.

Building the equipment maintenance assistant, we put the safety checklist on the server. And wrote this into the tool's description.

server.addTool(
  name: 'checklist.get',
  description:
      'Get the plant safety checklist for a machine type (press, conveyor, welder). '
      'These steps are set by the plant engineer and must not be paraphrased.',

A tool description is not decoration. It is text the model actually reads. And the instruction layered above it carries the same line.

- Safety checklist steps are the plant engineer's. Quote them in order and do
  not paraphrase, shorten or reorder them.

But an instruction is a request, not a guarantee. So the verification actually compares.

# The checklist must be quoted, not summarised — compare one line verbatim
grep -q "Verify emergency pull-cord continuity along both sides" captures/run.log \
  || { echo "a checklist step was altered on its way to the answer"; exit 1; }

This is how you stop "thirty years of ear evaporates". Ask that it not be moved, and have a machine compare whether it was. Without it in the pass condition, the request eventually goes unkept and nobody knows it went unkept.

The original identified judgment wearing away as the problem, but its remedy stopped at "build it yourself". Building it, one more remedy was needed. A device that checks whether what you wrote yourself is still there. Even if you write it yourself, a layer below you that summarises makes it evaporate all the same.

(The equipment assistant is in Put the Reason Next to the Answer.)

What the side receiving the judgment must not do

The original piece looked only from the domain expert's side. Building it, the other side needed discipline too.

Here is the equipment server's state handler.

// The server states facts and how those facts compare to limits.
// The machine never says "fine" — that word belongs to the person
// holding the checklist.
final overdue = (m['runHours'] as int) > (m['serviceEveryHours'] as int);
final vibrationOver =
    (m['vibrationMm'] as num) > (m['vibrationLimitMm'] as num);

serviceOverdue: true is a fact. safe: false is a judgement. Once the system starts making judgments on your behalf, "the eight tenths are in your hands" stops meaning anything. The expert holds the judgment, and if the tool reaches the conclusion first, that judgment goes unused.

So we add a half to the original's proposition. The eight tenths are in the expert's hands — and the system has to leave the place where those eight tenths will sit empty.

How far did the two tenths come down — and where the original is wrong

The original said the two-tenths wall came down. It did not measure how far.

Some of it can be measured now.

And here is where the original is wrong.

"Ten lines" appears in that piece. The point was that one screen fits in ten lines, and at the time what those ten lines actually were was never shown. Counted now, one piece of a rule really is seven lines. But one screen is one to two kilobytes, not ten lines. One button and one piece of text is ten lines; a screen that is actually useful is bigger. The original glossed over that gap.

A time comparison like "three days versus one hour" is in there too. There was no basis. This series has no measurement to substitute for it either — we have never built the same thing the old way and timed it. No comparison, no comparison written down. That sentence is cut here.

And one more. The two tenths came down, but they did not disappear. We edited the unmanned-store bundle into a laundrette and the labels changed while the items stayed ice cream. The screen is JSON so a domain expert can edit it, but what the items are and what the reorder point is are still outside the bundle. The boundary between what no-code reaches and what it does not is exactly there.

(That boundary can be seen as a picture in A Folder of JSON Is the App.)

The rehabilitation of the soft — the part still valid

The original's last axis was this. For a long time "hard things" (code, technology) were valuable and "soft things" (experience, instinct, an eye for it) were unpriced, and when the two-tenths wall comes down that valuation inverts.

Building it, this axis holds. We can attach one piece of evidence to it.

That the greenhouse rules carry not one character of a part number — that is the structure that makes the soft valuable. If a rule knows FX-200 it is bound to the part. Speak only in kinds and the rule outlives the part. The one that lives longer is the valuable one, and what lives longer here is the judgment "open it above 26 degrees".

What this sample did not do

We keep the original's honesty section and add what we learned.

This piece has no new sample. The code and logs quoted are all from earlier pieces. A horizon piece's job is not to build something new but to stand on what is already built, and the original's problem was pretending to stand where there was nothing.

Elapsed times of the "half a day will do it" kind were not measured. The original had a sentence to that effect, and this series has no measurement to replace it. How long a domain expert actually takes to write a rule can only be known by giving it to a domain expert, and we did not. The seven lines above were written by me, not by a farmer.

The eight-tenths / two-tenths ratio has never been measured either. It is the original's rhetoric and this piece did not verify it. Please read it as a figure of speech only.

We confirmed that a rule speaking in kinds survives, but not whether a domain expert can handle that format directly. The seven lines above are Dart syntax. Whether a farmer could write that as-is is a separate question, and this series did not answer it.

The place where judgment sits

The original asked — why does the person holding the eight tenths stop in front of the two?

Building it, we rewrite the answer a little. What stops them is not only the difficulty of the two tenths. It is that judgment wears away in transit, and that there is no way to check whether it is still there afterwards.

So three things are needed.

• A format in which judgment is written short — seven lines. No part numbers, only kinds.
• The discipline not to move it — in the tool description and the instruction.
• A device that compares whether it was moved — in the pass condition. Asking alone is not kept.

The last of the three was not in the original, and it is an item that does not surface unless you actually build.

The foundation is already there — that still holds. We add one line. Somebody has to check that the foundation does not wear away on its road to becoming a tool.

---

makemind.dev "Horizon" — The real size of one piece of judgment, and the device that stops it wearing away, paid in real things.