# configuration/strings/rationale.strings.ts

> 55 lines of code and 4 definitions.

Tree: Site tree
Language: typescript
Layer: product
Canonical: https://banes-lab.com/anatomy/tree#file-configuration-strings-rationale-strings-ts
Source text: https://banes-lab.com/assets/sources/source.3831515750bf7596fef0dea8349d65c47cc362fcf3c56dd61102a2174b5bf64a.generated.txt

## Definitions

- `VOCABULARY_SAMPLE` (lexical_declaration, line 6)
- `SOURCES_DIAGRAM` (lexical_declaration, line 9)
- `HONESTY_DIAGRAM` (lexical_declaration, line 12)
- `RATIONALE_SECTION` (lexical_declaration, line 15, exported)

## Source

```typescript
import { PAG_LANGUAGE } from "#configuration/constants/code.constants";
import { RATIONALE_SECTION_ICON } from "#configuration/icons/grammar.icons";
import { RATIONALE_SECTION_ID } from "#core/ids/grammar.ids";
import type { Section } from "#types/document.types";

const VOCABULARY_SAMPLE =
    "# code syntax · a structural pattern the model has completed many times\nFOR EACH <item> IN <collection>:\n\n# an english verb · the intent, readable by a reviewer\nANALYZE <held> AGAINST <schema>\n\n# a preposition · the relation between the operands\nREAD <config> FROM <file> INTO <settings>\n\n# together · one line the model completes and a reviewer can read\nEXTRACT <field> FROM <record> INTO <value>";

const SOURCES_DIAGRAM =
    'flowchart TB\n    code["Code syntax · loops, conditions, assignment"]\n    verbs["English verbs · analyze, validate, report"]\n    preps["Prepositions · FROM, INTO, AGAINST, USING"]\n    token["An uppercase token in a fixed slot"]\n    completion["A completion drawn from structured contexts"]\n    code --> token\n    verbs --> token\n    preps --> token\n    token --> completion';

const HONESTY_DIAGRAM =
    'flowchart LR\n    input["Input ambiguity · reduced"]\n    load["Interpretation load · reduced"]\n    variance["Output variance · narrowed, never removed"]\n    claim["The honest claim · tends toward consistency"]\n    input --> load --> variance --> claim';

export const RATIONALE_SECTION: Section = {
    icon: RATIONALE_SECTION_ICON,
    id: RATIONALE_SECTION_ID,
    intro: "The grammar does not change how a model behaves; it changes what the model is completing. A large language model predicts the next token from the patterns it was trained on, and a large share of that training is code, configuration and structured documentation. <cite>three sources</cite> writes those three sources into one line, and <cite>vocabulary origin</cite> shows how they combine. What that gains is limited, and <cite>the honest claim</cite> states the limit.",
    subsections: [
        {
            blocks: [
                {
                    application:
                        "In practice, every operative word comes from the keyword vocabulary, and its operands are bound with a preposition, so the model completes a recognised structure instead of interpreting a sentence. The intent is stated as an English verb the reader can review.",
                    boundary:
                        "Structure helps where the model has seen the structure. A vocabulary invented for one project is prose with capital letters, and the model interprets it as it would interpret a sentence.",
                    cause: "The model completes what it has seen most often, and uppercase verbs with explicit prepositions are what it has seen in code, configuration and documentation.",
                    decision:
                        "Ambiguity is reduced at the input and the output is verified, rather than the input being asked to guarantee anything.",
                    failureMode:
                        "A page of careful prose gets a confident result that answers a slightly different question, and the difference stays invisible until the result is run.",
                    kind: "lesson",
                    principle:
                        "For this reason I use explicit, high-frequency tokens, which reduce interpretive variance while the output stays probabilistic.",
                    problem: "Careful prose is not answered with a more careful result.",
                    validation:
                        "To check this, rewrite one prose instruction as a directive and run both several times against the same gates. The directive should pass more often, and where it does not, the gate that fails is the one whose condition was still a judgement.",
                },
                {
                    kind: "text",
                    text: "The vocabulary combines code syntax for structure with English verbs for intent and prepositions for the relations between operands. A line that carries all three is one the model can complete and a reviewer can read without a legend.",
                },
                {
                    kind: "text",
                    text: "Token frequency is the reason the vocabulary is uppercase and closed. A word that appears in the same slot across many structured contexts carries a stable meaning into the completion, while a word that appears with many meanings carries all of them. So the grammar keeps its verbs few and capitalised, and gives each one a semantic contract, stated under instruction patterns. One term for one operation is the ubiquitous language the model and the reviewer share.",
                },
                {
                    kind: "text",
                    text: "Reducing ambiguity works at the derive stage of the loop. There the model works out what a line means, and a line drawn from the vocabulary leaves it one reading where prose leaves several.",
                },
                { code: VOCABULARY_SAMPLE, kind: "code", language: PAG_LANGUAGE, title: "three sources" },
                { caption: "vocabulary origin", kind: "mermaid", text: SOURCES_DIAGRAM },
                { caption: "the honest claim", kind: "mermaid", text: HONESTY_DIAGRAM },
            ],
            title: "Pattern completion",
        },
    ],
    title: "Why it works",
};
```