# Meaning Becomes the Source
# Book: Language
# Chapter URL: https://programmer.ie/books/language/07-chapter/
# Prose fingerprint (sha256, normalized): 4d19aafe5e9e5fc4920259e9267e8a3b617c29d05b29774e06e685aadec042d8
# Snapshot generated at build time by Hugo. This is the complete rendered prose
# of the chapter; it is not a transcript of the source file.

Consider a constructed example: the payments retry policy from the previous chapter is rendered three times in one week. On Monday a system reads the passage and draws a state diagram. On Wednesday it produces a retry timeline for another task. On Friday it builds a table of backoff intervals. Each run begins with the same prose, but no shared interpretation exists that the runs could reuse or inspect. The risk is not that every fresh reading must differ. The risk is that any difference between the readings has to be discovered after the views are made, rather than checked against a common account of what they were meant to preserve.
Worse, the three can disagree. Monday’s diagram shows the partition exception redirecting to the dead-letter queue. Friday’s table omits the exception row for space. Wednesday’s timeline calls the third retry “final” without mentioning the partition. Each view looks plausible alone, but together they imply different behaviours. Only comparison with the original policy can establish which view, if any, is faithful. Agreement between views would not settle the question either. All three could faithfully repeat the same mistaken reading.
This is what direct generation looks like when a source can be rendered many ways:
SOURCE TEXT → representation A SOURCE TEXT → representation B SOURCE TEXT → representation C In this direct-generation arrangement, every view may depend on a separate interpretation. Re-reading does not guarantee drift, and a direct generator could itself use checks, caches or source-linked templates. The narrower problem is the absence of a shared, inspectable interpretation against which several views can be compared. This chapter examines one possible remedy. It is an architectural hypothesis, not a demonstrated improvement, and the simpler alternatives must remain competitors.
Three things, not two The bet is to make the interpretation explicit and reusable, rather than leaving it implicit in each rendering. The original source remains authoritative about what its author actually wrote. The intermediate record is a derived candidate that can be checked, corrected or rejected:
Proposed arrangement. Agreement among renderings does not establish correctness against the source. Open full-size diagram. Three objects now exist where before there were two, and the rest of the book depends on keeping them apart:
SOURCE ≠ SEMANTIC RECORD ≠ RENDERING The source is the canonical version of the original artifact being interpreted. It may later be revised, but a rendering must say which version it used. The semantic record is a derived account of that version’s claims, relationships, qualifications and source locations. It is fallible, versioned with its inputs, inspectable and rebuildable. The rendering is a task-specific presentation derived from the record. Keeping these identities separate matters. A later edit to the payments policy must not silently leave yesterday’s record and today’s diagram pretending to describe the same source state. From this follows an obligation:
Every consequential element of a rendering should identify the record entry it came from and the exact source version and passage supporting that entry. Traceability is required, but it is not proof of correctness.
This is the fixed-page escape hatch made finer. A reader ought to be able to move from a diagram edge or table cell to a record entry, and then to the relevant passage in the unchanged source version. A locator that merely points somewhere in the document is not enough. A cited passage can be genuine while the claim attributed to it is wrong. The walk back makes correction possible. It does not perform the correction.
Before the record The record also needs a construction instrument. The Understanding Compiler proposes one. It turns an identified source and admitted context into a candidate meaning inventory, which must be checked before any scoped acceptance turns it into a semantic record.
ORIGINAL SOURCE ↓ UNDERSTANDING COMPILER ↓ PROPOSED MEANING INVENTORY ↓ REVIEW / ACCEPTANCE within an identified purpose ↓ SEMANTIC RECORD ↓ RENDERINGS This is a proposed construction path. The compiler is the instrument. The record is a fallible derived artifact. A structured parser, a model and exact source links can make the proposal inspectable without making it correct. Acceptance records a reviewed interpretation and its limits, not permanent truth. The three-way distinction above survives the additional component.
What the record holds, and why The proposed record starts small. It is not an ontology of everything, and it does not claim to have recovered an author’s complete intention. Its fields are chosen to expose the losses illustrated in the preceding chapters. Whether this is the smallest sufficient structure is a testable claim, not something the schema’s existence establishes:
concepts what a passage is about claims atomic statements the source makes relations directed connections between claims or concepts qualifiers scope, condition, exception, uncertainty on each claim sequence ordering, where order carries content evidence pointers to the material backing each claim spans where in the source each entry came from Each field addresses a different failure. Claims identify assertions that a view might omit or alter, although splitting prose into atomic statements is itself an interpretive choice. Relations record which relation holds and in which direction: depends_on, precedes and causes are not interchangeable arrows. Qualifiers stay attached to the assertions they restrict, so an exception or a reported non-significant result cannot disappear unnoticed merely because it was written in a different sentence. Sequence records order when order matters. Source spans identify where an assertion was drawn from, and evidence status records what, if anything, the source offers in support. A quoted span establishes attribution. It does not establish the truth of the assertion or the correctness of its extraction.
Richer fields, such as argument structure, rhetorical role or cross-document identity, are deferred rather than ruled out. Some omissions will surface as an explicit not represented or ambiguous status. Others will be discovered only by comparison against the source. A schema that cannot express a decisive distinction must not force it into a misleading field just to produce a complete-looking record. Expand the schema when a measured failure requires it, and allow a source passage to remain unstructured in the meantime.
Two separations are deliberate. First, the record does not decide whether a claim should appear in a diagram or a table. Representation choice belongs to a later, task-specific stage. Second, the source record should not absorb a durable model of the reader. An immediate question such as “show the exception paths” may shape which entries a view selects. Reader attributes, inferred preferences and permissions belong to separate, governed context. Otherwise two readers could receive different alleged facts about the same source, because personalisation had contaminated the record itself.
What the extra layer buys, and what it costs The proposal is only worth taking seriously if it is stated as a trade, so here are both sides.
What it could buy.
One interpretation reused across views, so the diagram, table and timeline start from the same reading. Relations made explicit, with their type and direction, so a checker has something concrete against which to test an invented or reversed edge. The structure does not itself prevent such an edge. Provenance kept at source-version and passage level, so an element can be challenged against its origin rather than trusted because it carries a citation. A common substrate for checking renderings against declared record obligations, followed by independent checks that the record itself represents the source faithfully. Contradictions and qualifications represented once, instead of being reconstructed, or dropped, in each view. Renderings that can be compared with each other because they refer to the same thing. What it could cost.
The record can be wrong, and a wrong record is worse than none if everything is generated from it. Extraction can omit information that the prose carried and the schema had no place for. Structure can overspecify ambiguous prose, so a sentence that was deliberately vague becomes a crisp claim. One schema privileges the relationships it has fields for, and quietly deprioritises the rest. Views inherit the record’s errors, and do so with an air of consistency that makes those errors harder to spot. The record can become a false authority. Neat structure invites trust, and a shared extraction error can propagate consistently into every view. A revised source can make old spans, claims and renderings stale unless source identity and invalidation are enforced. That last cost deserves its own line, because it is the way this idea most easily goes wrong:
SEMANTIC RECORD ≠ SOURCE OF TRUTH A record is not true because it is structured. It describes what a particular source asserts, including errors, disagreement and uncertainty. It does not describe what the world has independently established. If the source asserts a causal link without supporting evidence, the record should preserve both the assertion and the lack of support. It should neither silently turn the assertion into a fact nor silently correct it. Three questions remain distinct: did the source say this? Does the source support it? Is it true? The record primarily addresses the first, can report evidence status for the second, and cannot settle the third merely by being well formed.
The same logic limits what the record can claim about meaning:
SOURCE ≠ SEMANTIC RECORD SEMANTIC RECORD ≠ COMPLETE MEANING This is where the loose word “meaning” of the early chapters receives an engineering boundary. No machine is claimed to have captured an author’s complete intention. The record represents selected, inspectable distinctions that a later transformation is obliged to preserve. Tone, rhetorical force, implication, ambiguity and whatever the schema cannot express remain in the source. Because the extraction is lossy, declaring a schema does not demonstrate that all important losses have been found. Before a record can guide a view, two different questions should be asked. Is each represented claim, relation and qualifier supported by the cited passage? And have the task’s required claims and exceptions been covered at all? A system may pass the first test while omitting the one condition that matters. Where either answer is unknown, the faithful output may be an unresolved item or the source itself, not a completed diagram.
The sources that break the careless Where would a reader see the difference between direct and mediated generation? Not on easy passages. A handful of constructions are easy to state and easy to destroy, and they show what the record has to hold:
A causes B only under condition C. D is associated with E, but the source explicitly rejects causation. Method X outperformed Y except in subgroup Z. The first requires a causal relation conditional on C. Dropping C turns a qualified claim into an unjustified universal one. The second requires two explicit distinctions: association versus causation, and the source’s rejection of the causal interpretation. A generic arrow cannot safely stand for both. The third requires the comparison to remain scoped outside subgroup Z. In each case the renderer must preserve the relation type, its direction and its attached conditions, or mark the view as incomplete. Checking whether the right words appear somewhere in the output is not enough. A diagram can print “except Z” in a caption while drawing an unconditional superiority arrow. These are constructed adversarial cases, not measured failure rates.
Here is the prediction on which the architecture should stand or fall. Given the same source and the same set of requested views, a shared semantic record might improve cross-view consistency, source fidelity and correction effort over direct generation. But consistency is not fidelity. A shared error can make every view agree on something the source never said. A useful study must therefore score cross-view agreement, each view’s accuracy against the frozen source, the record’s own omissions and mistakes, traceability, time and correction cost separately. It should compare against a strong direct-generation approach with the same source access, preservation instructions and checking budget, not against deliberately careless prompts. The alternative hypothesis is just as plausible. Extraction may add another loss point and no net benefit. No experiment reported in this chapter resolves that comparison.
A test that could reject the extra layer A proposed experiment would freeze a small set of source passages, together with an independently adjudicated ledger of required claims, relation types, directions, qualifications and deliberately unresolved ambiguities. The passages would include easy cases alongside negation, unsupported causality, exception paths, disputed claims and revisions that invalidate old offsets. For each passage, the experiment would request the same diagram, table and timeline under matched instructions and time or model-call budgets. It would compare direct source-to-view generation, shared-record-to-view generation, and a simple authored or template-based source-linked baseline where one is available. The source and evaluation cases stay fixed across conditions, and outputs are assessed without revealing which pipeline produced them.
The first measurement checks the record against the source, before any view is judged. The second checks each view against the source, not merely against its sibling views or the record. Record agreement, missing obligations, unsupported additions, false certainty, locator validity, latency, correction effort and explicit abstentions are each recorded separately. A deliberately corrupted-record condition would establish whether a shared error is caught or simply reproduced. A record earns its complexity only if it improves fidelity or other predeclared outcomes without unacceptable new costs. These are proposed conditions, not experiments that have been run.
Running it The chapter documents a reference example in ernanhughes/project-language, invoked as npm run example:ch07. It takes a constructed payments policy and one hand-written record, then renders a diagram, table and timeline through a Pi host using a scripted stand-in for the model. This is a test of plumbing and declared checks. It is not evidence that a model can extract the record, or that the representation helps a reader. The command and behaviour are described as reported by the project. This chapter review does not independently rerun that repository.
In the reported example, entries quote passages and character positions, and the three views carry the expected exception phrases while naming the record entries they came from. Before rendering, checks require the declared source identity, non-empty quoted passages present in that source, and conditions located inside their cited passage. The schema also excludes reader attributes. A separate constructed passage exercises checks for a dropped condition, a causal upgrade of an association and a missing comparison exception. The example preserves an unsupported causal assertion as an assertion rather than correcting it silently. These are useful structural checks on supplied artifacts. Passage containment and field validity do not independently establish the semantic correctness, completeness or temporal freshness of the record.
This does not test the chapter’s comparative hypothesis. The contrasting direct renderings were authored to drift, and the checker observes phrase presence rather than whether the represented relations are faithful. There is no independent extraction test, matched direct-generation baseline, live-model comparison or reader study. The implemented representation also places entities among the claims, instead of supplying the separate concepts field in the illustrative schema above. A runnable demonstration shows that a shared record can coordinate renderers and enforce declared structural constraints. It cannot yet show that those constraints capture the distinctions readers need, or that adding the record improves results.
Where this leaves us If one source is rendered in several ways, a reusable, source-linked record is a plausible place to declare what those renderings must preserve. It is not the source, not a truth oracle, and not automatically the minimum necessary mechanism. Its value depends on source-version identity, independently checked extraction, coverage of the required distinctions, and a path from each consequential rendered element back to the original passage. If a required distinction cannot be represented or checked, the system must be able to expose that limit and leave the source available, rather than silently manufacturing a definitive view.
That is the larger possibility beneath the example. Dynamic representations need explicit preservation obligations, but the book has not yet shown that one shared record is always the best place to hold them. If the hypothesis survives its tests, a reusable record becomes a candidate substrate for more than rendering. It can identify the claims, relations, uncertainty and source locations about which a reader might want further evidence. The next chapter asks how the channel constructs and exposes its proposed reading. Then Enhanced Interaction asks how a reader distinguishes that reading from material inferred or found elsewhere.
References Cao, Y., Jiang, P. & Xia, H. (2025). Generative and Malleable User Interfaces with Generative and Evolving Task-Driven Data Model. Proceedings of CHI 2025, article 686. DOI 10.1145/3706598.3713285. (A precedent for an editable task-driven data model behind generated interfaces, not evidence that a semantic record of a document preserves its claims.) Liang, C. & You, J. (2025). Evaluating LLM-Generated Diagrams as Graphs. Proceedings of EMNLP 2025, 12678–12690. DOI 10.18653/v1/2025.emnlp-main.640. Preprint: arXiv:2510.25761. (Distinguishes node alignment from path alignment when evaluating generated research diagrams; does not establish a universal frequency ranking of diagram errors.)