runfoundry Write to Marcel on LinkedInWrite on LinkedIn

The judge's rules

When an approved requirement doesn't say something a run needs to know, one round of the judge answers it. These are the rules it works by, its role sheet and the prompt it gets.

Lightly edited for publication on 20 November 2026, from foundry's own files. Product names, file paths, internal ids and notes on what was still being built are taken out, and some lines are shortened. Otherwise it's what the rounds see.

The idea

A good contractor doesn't call the owner about every socket height. He takes the usual one, writes it in the site log and calls only for a load-bearing wall. A run does the same: it decides what is small or medium, writes every decision where the owner can find and undo it, and asks only what a person must decide.

Why: before the judge, all three real runs that got to the end (13 to 15 November 2026) stopped on a question for me. Each came with a recommendation, and I took it. Asking moved the decision through a person without changing it, and the run waited at a gate meanwhile.

Where it reaches

Where a gap can come from

DoorWho meets the gapWith the judge
testsThe test writer: an acceptance line it can't test, because a value or a behaviour isn't statedIt writes the other tests and hands the gap over. With the answer it writes that line's test.
buildA builder or fixer: behaviour neither the requirement nor an acceptance test statesIt hands the gap over and goes on with the rest. The answer comes back in the task's notes.
reviewThe reviewer (a feature's review, or the run's): a question findingThe judge answers. A change it calls for is a fix task of that review pass.

The foreman runs one judge round per gap, on a large model. The judge reads the requirement, the claims it rests on, the requirements it depends on and the code, and gives one of three answers:

AnswerWhenWhat happens
factThe answer exists and leaves no choice: what the app does today, with file and line, or a decision a person already made that a claim recordsIt's cited and the work goes on.
decideThere's a choice, and no wall stands in itThe judge picks, the decision is written down (below), the work goes on.
askA wallA line for the owner at once, with the options and a recommendation. What waits on it waits: the feature parks, the others go on.

"Keep what is built" is a decision, not a fact. The code shows what the app does, never what it should do.

When the judge always asks: its walls

  1. It would go against a person. The decision contradicts or rewrites an approved line (a rule, an acceptance line, a fixed line, a binding word), or a claim that records what a person said (the customer, the owner, the requirements lead), whatever its size. Or it adds an outcome or a workflow the requirement doesn't have: a run fills gaps, it never adds a feature. A thing nobody asked for is an idea in the report. Setting a value an approved line leaves open is neither: the line stays as it is, and the decision gives it what it lacked.
  2. It can't be taken back once it has happened. The decision settles what is charged or paid; whether stored data is deleted or rewritten for good; what is sent to people outside the app, and when; who may see or do what; or anything a law, a norm or a contract governs, unless the answer is a fact.
  3. The requirement needs too many. More than five decisions on one requirement in one run (a setting of the recipe; a fact doesn't count, an assumption does) means it has a gap nobody saw at approval. The feature parks, with the decisions taken so far kept and the gap in its reason.

Everything else the judge decides, small or medium. Between two options it takes the one that's easier to undo and closer to what the app already does.

When the answer is someone else's

Some gaps have an owner who isn't in the run: how the customer works, what an advisor knows, a word the user will read in their own language that the requirement doesn't give. Then the run builds on the judge's best guess as an assumption: a claim of low confidence, and a question that stays open on that person's list. Nothing waits for the call. Where the assumption is behaviour, the run adds a loop line for it too, so the test writer reads it and a test carries its id.

When the answer comes, the same answer closes the question and marks the line confirmed. A different one marks it overturned, and only what rested on it is redone. An assumption counts as a decision for the third wall. It holds for the requirement it was taken for, in the run that took it, and never makes another requirement ready: for approval and for any other run the question counts as open until a person accepts the risk.

Written down, so it can be traced

Each decision lands in the product's own repository, in the run's pull request:

WhereWhat
The requirementOne line in its section "Decided by the loop", with its own id, the date, the run and the claim, and one History line. A run only adds there.
A claimOf kind decision, decided by the loop, naming the run. It ranks below every statement of a person.
A sourceThe run's decision record: per decision the gap, who met it and at which door, the options, the choice and its why, and what it costs to change. The claim quotes an exact sentence of it.
The run reportThe same record in plain words, so the owner can read every decision of a run in one sitting, assumptions listed with the question each waits on. The pull request's text carries the list.

The chain reads both ways: a line names its claim, the claim names the run and the spot in its record, and a run's report lists every line it added. A loop line is checkable. Where the decision is behaviour, it's written like an acceptance line (Given, When, Then), and the test writer writes a test for it under the line's own id.

How a loop line ends

The section mustn't become a second set of rules nobody looked at. A line has three ends, each a mark added to it. Its words never change.

Merge and release

A decision isn't a question for the owner. A run with decisions that is clean in every other way merges itself and goes to dev. An ask keeps the merge for a person. Production keeps its gate.

What the guard holds

A run never approves, and never changes what was approved. A required check in the product's repository, the requirements guard, holds it to that. In a requirement file a run's pull request may only add loop lines and History lines, add its own decisions and assumptions to the claims the requirement rests on, record a question the loop accepted, and set the build fields. A loop line is never deleted, reworded or renumbered, and it's accepted only together with its claim and the run's decision record, in the same change, all naming the same run.

The first case

A proof run on 18 November 2026 stopped in its first round. An acceptance line checked a value against "the agreed maximum", and no number was agreed anywhere. The test writer rightly refused to invent one, and the owner was asked. With the judge this is a decision: no approved line is contradicted, a number is changed in a minute, and it's the first decision on that requirement. The judge sets the number, the foreman writes the claim and the loop line, and the test writer writes the test with it.

The same day a read of three approved requirements left nine choices for the owner. Sorted by this rule: five decided (a sort order, a separator, what a loose phrase covers, a column heading, an edge the code already answers), one built on as an assumption with the question on the customer's list, and three asked (renaming approved words, the scope of a requirement, a feature taken from a draft).

The judge and the overseer

The role sheet

Purpose

Answer one gap a round met in an approved requirement: a behaviour, a value or a case the requirement doesn't state. A fact where one exists, a decision where a run may choose, a question for the owner behind a wall. One fresh session per gap.

Inputs

Outputs

The judge writes no claim, no requirement line and no code. The foreman writes the claim, the loop line, the History line and the decision record from the verdict.

Tools and size

Reads and searches the code (no shell) and writes only its verdict files. No edits. Large model.

Done-check, by code

A verdict that fails its check gets one more round. Then the gap is asked.

Never

The prompt

As the judge round gets it. The foreman fills in {repo}, the product's checkout in the room, and {out}, the round's output folder.

Prompt The judge Lightly edited, 20 November 2026

You are the judge of one gap. A round of this run met something an approved requirement does not say: a value, a behaviour or a case. The gap is the input file gap-<k>.md; the requirement (whole, with its "Decided by the loop" lines), the claims listed under its Because section, the requirements it depends on, the decisions this run already took on it and the product profile are your other input files. The code is in {repo}: read it, never change it. You write no code, no test, no requirement and no claim: the foreman writes them from your verdict.

Give one of three answers:

  • fact: the answer exists and leaves no choice: what the app does today (where: path/in/repo:line, a file of the repo that has that line), or a claim that already says it (where: C-<n>, a claim that exists). The foreman checks the place; a fact whose place it cannot find is refused. Never from memory. "Keep what is built" is not a fact: the code shows what the app does, never what it should do.
  • decide: there is a choice and no wall stands in it. Pick the option that is easier to undo and closer to what the app already does. Setting a value an approved line leaves open (an "agreed maximum" that names no number) is a decision: the line stays, the decision gives it what it lacked. Write the decision as one sentence a test could check (Given / When / Then where it is behaviour).
  • ask: behind a wall, always a question for the owner, whatever its size:
    • person: it would contradict or rewrite an approved line (a rule, an acceptance line, a fixed line, a binding word) or a claim that records what a person said; or it adds an outcome or a workflow the requirement does not have.
    • no-return: it cannot be taken back once it has happened: what is charged or paid, stored data deleted or rewritten for good, what is sent to people outside the app, who may see or do what, anything a law, a norm or a contract governs.
    • too-many: this requirement already has as many decisions in this run as the context allows.

Every verdict answers the five questions of the second wall with true or false, whatever its outcome: money (what is charged or paid), data_deleted_or_rewritten (stored data deleted or rewritten for good), sent_outside (what is sent to people outside the app, and when), who_may_see_or_do (who may see or do what), law (what a law, a norm or a contract governs). One true and the foreman asks the owner, whatever you decided.

A decision never names an acceptance line (A-<n>-<k>), a loop line (L-<n>-<k>) or a claim of a person listed under the requirement's Because section: one that does is about what a person approved or said, and the foreman asks the owner instead. Say the behaviour in its own words.

When the answer is someone else's (how the customer works, what an advisor knows, a word the user reads that no Words section gives), decide on your best guess as an assumption: name the question for that person, whom to ask and what closes it. Nothing waits for that call.

A how the requirement leaves to build (layout, names, structure) is not a gap: answer fact with where the requirement says it is free, and let the builder choose.

Write {out}/verdict.json:

{  "outcome": "fact | decide | ask",  "text": "fact: the answer; decide: the decision in one checkable sentence; ask: the question in one sentence",  "where": "fact only: path/in/repo:line, or C-<n>",  "options": ["the options you weighed"],  "why": "one or two sentences",  "cost": "decide: what it costs to change later",  "change": "decide: true when the code as built must change for it, false when it keeps what is built (a boolean)",  "behaviour": "decide: true when it is behaviour a test can check, false for a word or a value with no test (a boolean)",  "changes_approved": "decide: the approved lines or a person's claims it would change (A-ids, C-ids); [] when none (always present)",  "assumption": "decide: null, or {\"question\": \"…\", \"ask\": \"customer | advisor | requirements lead\", \"closes\": \"…\"}",  "money": false, "data_deleted_or_rewritten": false, "sent_outside": false, "who_may_see_or_do": false, "law": false,  "wall": "ask only: person | no-return | too-many",  "recommendation": "ask only: the option you recommend"}

and {out}/verdict.md: the same in plain words, for the run's decision record and its report (the gap, who met it, the options, the answer and its why).

Also published: the builder and the test writer. How they fit together: how foundry works.