Source-adoption policy

Type: kb/types/note.md · Tags: foundations

Commonplace draws its design from programming-language theory, cognitive science, HCI, legal drafting, and direct observation of its own use. Any source is admissible — the related-systems reviews exist to widen the input surface — but the adoption gate differs by source. This document records the policy the framework applies and the rationale it states for each gate; the policy is a working stance, not an established theory of cross-domain transfer.

The programming fast pass

Commonplace adopts programming patterns — types, validation, testing, progressive compilation, version control, structural typing, the maturity ladder as gradual typing — without first deriving why each transfers. The stated rationale is a bet: that agents interpreting prompts and interpreters interpreting programming languages are both bounded processors composing text under constraints, so the patterns transfer by shared mechanism rather than by analogy. The framework treats this as a hypothesis it operates under, not a demonstrated identity.

The parallel the bet rests on is that programming systems are formal, compositional, and text-based, and so is the KB — formal (frontmatter schemas), compositional (notes link and compose), text-based (markdown files). The policy applies the shared-mechanism reading most confidently to the symbolic shell — schemas, validators, typed artifacts, version control — where the substrates genuinely coincide. It does not extend the identity claim to the LLM's interpretive core, which still reads underspecified natural language probabilistically; patterns that depend on deterministic execution semantics fall outside the fast pass.

The framework cites Thalo — an independent project that built compiler-like tooling for knowledge management (a Tree-Sitter grammar, typed entities, a validation-rule set) — as convergence evidence: a separate team reached for the same toolbox. This is treated as corroboration for tooling of this kind, not proof of wholesale transfer, since it is equally consistent with shared engineering priors.

First principles: the gate for everything else

For non-programming sources, the gate is first-principles support: a pattern is adopted with confidence when the framework can derive why it works from the domain's constraints — finite context windows, no import/resolution mechanism, text-only reasoning, everything loaded competing for attention. Context loading economy and directory-scoped types are examples: both follow from the constraints without an analogy.

Cognitive-science and HCI patterns pass only when first-principles reasoning supports them. Three-space memory is adopted because it maps to a real architectural need — separating concerns with different churn rates — not because Tulving's taxonomy is authoritative for LLM agents. The cognitive-psychology claims in the Ars Contexta review are acknowledged but not adopted wholesale; a spreading-activation model may not predict how a large context window behaves. The asymmetry with programming is not about field quality but about target fit: human cognition is associative, embodied, and affective, while LLM agents process text in a fixed window with no persistent cross-session state, so cognitive-science analogies need independent justification.

Law has long methodology for the same problem — writing natural-language specifications interpreted by a judgment-exercising processor — and unlike programming it shares the prompt's medium: natural language with irreducible ambiguity. The structural parallel is close (precedent constrains; canons of interpretation narrow the reading space), but the framework has not yet borrowed a concrete legal technique and applied it successfully. Until it has, legal drafting stays an eligible source, not a fast pass.

Direct observation: a separate path

Direct observation of what works in this system — the improvement log, friction notes, prose reviews — does not go through the borrowing gate at all. It is evidence from the system itself, not transferred from another domain; the verifiability gradient, for instance, was found by watching patterns in use. The framework weights observation and constraint-derived design differently: observations are plentiful but individually weak (a single one may be a local quirk or an artefact of current scale), while inherited constraints are scarce but each is strong for as long as the commitment that forces it holds. Observations accumulate into confidence by recurring; a constraint-derived argument carries its confidence from its commitment and loses it if that commitment changes. Per the wikiwiki principle, observations are captured freely and refined, and the ones that recur across sessions graduate into durable patterns worth codifying.

Relevant Notes: