Closed decisions belong in code

Every Monday the dinner planner runs again. Leena's cashew allergy is the same fact it was last Monday, portion arithmetic for four people follows the same ratios, and both checks still travel through a language model because nobody moved them out of the prompt.

The model gets both right most of the time, which is precisely what keeps the arrangement in place. When the allergy check does miss, the failure arrives dressed as a judgment error and gets diagnosed as one, so somebody spends a week adjusting the wording of a template in an attempt to fix a comparison. Nothing in the feature description told them the check was supposed to be exact.

Hardening it is a placement correction rather than a cost optimisation, and it has two halves that teams collapse into one. The first is establishing that the decision genuinely qualifies as settled, which requires a stronger bar than "usually right". The second is writing the close down, so that the enforcement point, the failure mode, and the test survive the handoff to whoever maintains the path next. Closes that go wrong almost always went wrong at the first half and were never recorded well enough for anyone to notice.

Helpful context: Open, closed, and closing supplies the two questions that produce the closed answer, and this page is the affirmative corollary for that answer. The price of closed work left open prices the delay in money and trust. Hard rules and soft constraints (next in this track) separates the requirements that can close from the ones that cannot.

Closing is progress, not lost ambition

Teams hesitate to harden because a roadmap that removes model calls reads as a roadmap in retreat. That reading has the ambition backwards. A system that keeps rediscovering work it already knows how to do reliably is paying twice, once to learn the rule and then again, every run, to reconstruct it, and the second payment buys nothing that the first one did not already deliver.

What closing buys is scope for the part of the system that genuinely needs cognition. When the closed links leave a cognitive unit, its evaluation suite is about one thing and its accuracy figure means something specific. A suite covering a practicality judgment and a portion calculation together produces a number that improves when either half improves, which makes it close to useless for deciding what to work on next. Closing is therefore how open judgment becomes measurable, rather than a concession that some of the product is boring.

It also changes what a failure means. Once allergy enforcement lives in validation, a miss is a bug with a failing test and a named module that owns it. While the same check lives in a prompt, the same miss is a bad day for the model, and the team is routed toward tuning when the correct response was removal. Closing is the move that gives an exact failure an exact address.

The bar for calling a decision settled

The sort returns closed when competent people agree and the rule can be written, and under delivery pressure both of those answers get rounded up. So the useful form of the bar is several signals that have to converge, because a team can talk itself past any one of them alone.

Signal	What it means
Two competent people always agree	The decision has a determinate answer
The rule fits in a sentence without "it depends"	The procedure is writable
Wrong answers are bugs, not disagreements	Correctness is binary rather than graded
The fact or rule has been endorsed	Code enforces a decision, not an inference from context
Re-running a model adds no information	Nothing is being discovered, only reproduced

Only the last row can be checked against production traffic rather than argued in a room, which is what makes it worth reaching for first. If the same inputs produce the same answer every time and the answer never surprises anyone, the model is being paid to reproduce something the team already knows.

A row that fails does not leave the decision homeless. Agreement without writability puts it in closing territory, where a named cognitive unit holds it while the rule becomes legible, and how decisions close traces that path. Genuine disagreement means hardening now would freeze a judgment as a threshold nobody can later justify, which is the mirror error mistakes both ways treats alongside this one. The conservatism is deliberate, because closed has to mean that the answer does not change shape when a vendor updates model weights.

If competent people agree and you can write the rule, it is code, not a cognitive unit.

The cognitive unit · Ch. 5

What closing actually commits you to

Two of the four decisions in a close determine each other: which rule code will enforce, and where the enforcement runs. The rule has to be the endorsed one rather than whatever a model infers from the conversation, which is why knowledge is endorsed, not retrieved is a precondition and not a refinement. Position then follows from the rule, because an allergy rule applied after a plan has been drafted in prose is applied too late to prevent what it exists to prevent. Allergy validation belongs before candidate generation, and a spending gate belongs before commit.

The third decision is what happens when the check fails, and it is the one most often left implicit. Refusing, blocking, and escalating are different behaviours with different consequences for the household, and the one behaviour a closed rule cannot have is silent override, because a rule that yields to a confident model is a preference wearing a strict name. When an ingredient cannot be classified reliably, the honest result is that validation returns unresolved and asks for human confirmation. The agent may respond by retrieving better information or asking the household, and it may not respond by overruling the check.

The fourth decision is the test, and it is what makes the other three durable. Inputs that must pass, inputs that must fail, and a regression case for the day the rule changes turn the close into something a later team can rely on without reading prompt history. Closed work in code with no test is closed by accident, and it drifts back into a fluent guess the first time somebody refactors the path.

Individual closes accumulate into a layer rather than staying scattered across the codebase. Allergy enforcement ends up beside portion calculation, plan versioning, permission checks, and the purchase approval gate, and together they are the part of the Meal Companion that stays exact so that cognition can spend its budget where interpretation is genuinely required. Deterministic code beside cognition develops that layer as an architectural commitment, and deterministic guards before cognition covers how closed checks are ordered in front of expensive judgment.

What this looks like in practice

Two rows of the Weekly Meal Companion terrain table clear the bar once knowledge is endorsed, and a third sits close enough to show where the line falls.

Identifying confirmed allergies is exact the moment Leena's cashew allergy is endorsed as household knowledge. The system does not weigh trace amounts, does not grow more confident with practice, and does not improvise when a restriction is unfamiliar. An unfamiliar restriction is not an exception the close forgot about, it is the failure mode the close declared, so validation returns unresolved and leadership goes back to the household or to a professional.

Calculating portions clears the bar for a different reason, which is that the inputs settle the answer completely. A wrong output is a bug rather than a disagreement, and when the household count changes from four to five the system recalculates instead of reasoning linguistically about quantities again. That is the practical payoff of the close, because correction became cheap the moment arithmetic stopped being entangled with meal selection.

Judging whether a meal suits a busy evening does not clear the bar, and it sits one row away from work that does. AssessMealPracticality owns that judgment with a suite attached, and the twenty-five-minute budget for active effort inside it is the fragment most likely to close first. Closed and closing are neighbours, so the signals are what tell them apart rather than an intuition about which one feels more like code.

Nor does a close usually retire the judgment completely. A rule that covers most of a class leaves the rest uncovered, and the honest structure is a deterministic path for the covered cases with the cognitive unit kept as the fallback for the others. The fallback rate then becomes a measurement worth watching, since a rule that covered nine cases in ten last month and covers eight this quarter is reporting that the incoming work changed.

Why deferral wins by default

The rationale for waiting is reasonable every time it is offered. The prompt path shipped the demo, engineering bandwidth is committed elsewhere, and the check usually works. None of those statements is false, and together they guarantee that later never arrives, because nothing on any dashboard reports the absence of a close.

Meanwhile the delay hides itself. Evaluation reports respectable curves on work that was never meant to be probabilistic, and when a rare failure eventually surfaces, incident response reads it as model quality because nobody recorded that the check was always supposed to be exact. What the waiting costs in money and trust is worked out in the price of closed work left open. The part this page is responsible for is prior to the cost, because the bill stays invisible until somebody writes down which work should have been closed.

Which is why the close belongs in the architecture artifact rather than only in a commit message. What was open, what evidence endorsed it, what code now owns it, and who approved the migration are four lines that let a later reader see the placement as a decision. Without them the next team inherits allergy enforcement sitting in validation with no way to tell a deliberate close from an accident of history, and the safest thing available to them is to leave it untouched, which is also the thing that stops the architecture from learning anything further.

What to do next

The signal worth hunting is an evaluation suite reading a hundred percent, because it gets filed as good news when it usually means a cognitive unit was handed a decision that had already settled, with the rule sitting in the very cases the suite just graded. Mistakes both ways collects the other traces pointing in the same direction, and any one of them is enough to start running the bar on a real path.

What follows is specification rather than discovery, which is why closing takes less engineering than it takes authorisation. The endorsed rule, the enforcement point, the failure mode, and the test are all recoverable from the cases that made the decision look settled in the first place. Continue with hard rules and soft constraints, because a requirement that mixes an absolute rule with a trade-off fails this bar taken whole while containing a part that clears it easily, and separating the two is what makes the close possible at all.

Read next: Hard rules and soft constraints.