Notes Directory

Type: kb/types/index.md

← Parent

Subdirectories

• agent-memory-requirements/
• definitions/
• evidence/
• research/

Files

• "Agent" is a useful technical convention, not a definition (note) - A lightweight technical convention — an agent is a tool loop (prompt, capability surface, stop condition) — sidestepping the definitional debate in favor of a unit that organizes code
• A citation cannot assert more fidelity than its capture preserved (note) - Capture is layered (verbatim / paraphrase / second-hand) by forced constraints; a citation's fidelity is bounded by which layer holds the passage, and no notation can raise it — only re-capture
• A compact, refreshable whole-picture narrative can replace infeasible fragment reconciliation (note) - Holistic rewrite shifts reconciliation from each consumer to the author, but only when the whole-picture narrative can fit within effective context and be refreshed before the narrative goes stale
• A consumption channel delivers force without the history that earned it (note) - A consumption path can promote content into a higher-force role without checking whether an authorization covers that content, version, and use
• A derived copy of recomputable truth must be checked or absent (note) - When an artifact carries a copy of information recomputable from a ground-truth source, the copy must be machine-checked against that source or not exist — hand-maintained-and-trusted is forbidden
• A functioning knowledge base needs a workshop layer, not just a library (note) - Explains workshop as the temporal counterpart to a permanent knowledge library: in-flight state, dependencies, expiry, and promotion bridges, with tasks as an early prototype
• A goal-holding interpreter fails soft, and its workarounds tax a bounded budget (note) - A procedure compiles its goal away, so a blocked step fails loud and hard; an interpreter holds the goal and re-routes, so failures are absorbed as a per-encounter tax on bounded capacity — silent, accumulating, and softly saturating
• A knowledge base holds theories, descriptions, and prescriptions with asymmetric linking (note) - Theory, description, prescription are recurring attractors, not a provable partition; formulation constraint and maintenance asymmetry make the split real; content is orthogonal to operational roles
• A knowledge base should support fluid resolution-switching (note) - Good thinking requires moving between abstraction levels — broad for context, narrow for mechanism, back out for pattern. A KB's quality should be measured by how fluidly it supports this resolution-switching, not just retrieval accuracy.
• A methodology governs its own extension only as far as it settles the meta-decisions it raises (note) - A methodology governs its own extension only as far as it settles the meta-decisions its recommendations raise — representational form, verification, and authority
• A proposal-selection improvement loop requires search, evaluation, and operative retention (note) - A proposal-selection improvement loop — candidates generated, evaluated with possible non-adoption, selectively retained — requires search, evaluation that can reject, and operative retention
• A proximate target is checked for achievement, not for warrant (note) - Between an improvement objective and its oracles sits a target level — a property pursued because it is held to serve the objective — whose linking claim no check in the loop evaluates
• A universal knowledge framework demotes content taxonomies to defaults and keeps answerability (note) - Universal frameworks should keep closed first-order content taxonomies as guarded defaults until heterogeneous worked cases establish their explanatory-reach; declared contracts and answerability remain universal
• Abstract an experience into a lesson only when you can state where the lesson stops (note) - Abstract an episode into a lesson only when you can state its boundary, else preserve the instance; an over-generalized lesson is one that drops the condition clause
• Access burden and transformation burden are independent query dimensions (note) - Queries have two independent difficulty axes — finding inputs (access) and producing the answer (transformation) — conflating them misroutes symbolic transformations through semantic processing
• Accumulation counts dependence through the retained result, not through the evidence it caused (note) - Cumulativity counts dependence through the retained result only; counting the evidence channel that result caused would make it coextensive with operativity
• Active work state is not retrospective memory or chat history (note) - Active work state needs current pointers, evidence gates, and closure; treating it as retrospective memory or chat history preserves the wrong state
• Ad hoc prompts extend the system without schema changes (note) - Any system with an LLM agent layer can absorb new requirements through natural language prompts without changing the deterministic base
• Agent context is constrained by soft degradation, not hard token limits (note) - Agent context is bounded by silent reliability degradation across volume, complexity, and relevance/interference, not just by provider token limits
• Agent memory (tag-readme) - Curated head for agent-memory notes — memory as crosscutting architecture, requirements, activation, lifecycle, and evaluation
• Agent memory is a crosscutting concern, not a separable niche (note) - Memory decomposes into storage (solved), retrieval/activation (context engineering), and learning (learning theory) — treating it as a standalone category hides that the hard problems are at the intersections
• Agent memory needs discoverable, composable, trusted knowledge under bounded context (note) - Frames discoverable, composable, trusted remembered knowledge as the minimal artifact-quality basis for agent memory under bounded context.
• Agent orchestration needs a privilege quarantine, not just a permission scope (note) - When one agent in an orchestration reads untrusted content, the defense is a role-level privilege quarantine — barring that agent from high-privilege actions entirely — not finer per-call tool scoping
• Agent orchestration needs coordination guarantees, not just coordination channels (note) - Coordination channels say how bounded contexts interact, but the missing discriminator is which guarantee prevents contamination, inconsistency, amplification, or liability diffusion across the composed system
• Agent orchestration occupies a multi-dimensional design space (note) - Agent orchestration is not ordered along a single ladder — scheduler placement, persistence, coordination form, coordination guarantees, and return artifacts vary independently across architectures
• Agent runtimes decompose into scheduler context engine and execution substrate (note) - Practitioner runtime taxonomies converge on three separable components — scheduler, context engine, and execution substrate — because each solves a different class of model limitation
• Agent statelessness makes routing architectural, not learned (note) - Because each session starts without learned navigation intuition, skills, type templates, routing tables, names, and activation triggers remain permanent architecture rather than temporary scaffolding
• Agent statelessness means the context engine should inject context automatically (structured-claim) - Since agents can't carry vocabulary or decisions between reads, the context engine should auto-inject referenced context — definitions once per session, ADRs when relevant. The trigger mechanism is open; the need follows from statelessness
• Agentic systems interpret underspecified instructions (note) - Separates semantic underspecification from execution indeterminism: natural-language specs admit multiple valid projections, while constraining commits one projection to precise code.
• Agents navigate by deciding what to read next (note) - Context surrounding a pointer determines how cheaply an agent judges relevance without loading the target; inline links carry most, search results least — descriptions are load-bearing
• AGENTS.md should be organized as a control plane (note) - Theory for deciding what belongs in AGENTS.md using loading frequency and failure cost, with layers, exclusion rules, and migration paths
• Alexander's patterns connect to knowledge system design at multiple levels (note) - Maps Alexander's Context/Problem/Forces/Solution pattern to typed document contracts and his generative process to incremental codification, while marking the looser 'centers' analogy
• Always-loaded context mechanisms in agent harnesses (note) - Survey of always-loaded context mechanisms across agent harnesses — system prompt files, capability descriptions, memory, and configuration injection — cataloguing what each carries, how write policies differ, and where the gaps are
• An accepted edit verifies the change, not the rule (note) - Human acceptance of an edit is a strong oracle for 'this change was wanted here' but a weak oracle for 'this generalizes' — mining rules from accepted edits inherits instance-level verification while the generalization step stays oracle-poor
• An action model matters only through its consumption path (note) - Agentic action can be direct or model-mediated; a retained action model matters only when its consumption path affects intervention selection
• An adversarial human-agent loop can reconstruct the writing-is-thinking filter (note) - The writing-is-thinking filter is the loop's, not the pen's — an adversarial human-agent loop can reconstruct what naive delegation loses, but only while the human stays the judge
• An author should fix what the executor can't determine, not what it will (note) - Separates arbitrary choices authors must fix from situational details executors can determine, preventing stale plans and prompts from consuming the live executor's search space
• An enforced tag-README is a MOC with a machine-checked contract (note) - Tag-READMEs inherit the Zettelkasten/LYT Map-of-Content tradition; the complete/covered_by marks add a completeness contract human PKM never made — humans neither needed nor could cheaply enforce it
• An LLM's generation confidence tracks typicality, not soundness (note) - An LLM's next-token confidence measures how typical a continuation is, not whether it's true or valid; the two are decoupled, so soundness can't be read off confidence and needs a separate check
• An outcome check licenses replay; a rule needs the process verified (note) - Outcome and process verification are two verify-rung oracles — an outcome check licenses replaying an instance, not abstracting a rule, since only a process check inspects the generalizing mechanism
• Any symbolic program with LLM calls is a select/call program (note) - Any program whose non-LLM steps are symbolic computation over explicit machine state K can be mechanically converted into the select/call loop with the same LLM calls in the same order
• Apparent success is an unreliable health signal in framework-owned tool loops (note) - When framework-owned tool loops recover from broken tools via agent workarounds, final success stops being a reliable signal that the underlying scripts and workflows are healthy
• Architecture (tag-readme) - How Commonplace is structured and installed — repo layout, two-tree split, control-plane design, file-based storage
• Areas exist because useful operations require reading notes together (note) - Areas are defined by operations that require reading notes together — orientation and comparative reading — which need sets that are both small enough for context and related enough to yield results
• artifact-analysis (tag-readme) - Curated head for the artifact-analysis tag — the four-field vocabulary (substrate, form, lineage, authority) for classifying retained behavior-shaping artifacts, plus its applications
• Automated synthesis is missing good oracles (note) - Generating synthesis candidates (cross-note connections, novel combinations) is easy — LLMs do it readily. The hard part is evaluating whether a candidate is genuine insight or noise.
• Automated tests for text (note) - Text artifacts can be tested with the same pyramid as software — deterministic checks, LLM rubrics, corpus compatibility — built from real failures not taxonomy
• Automating KB learning is an open problem (note) - The KB already learns through manual improvement; automating judgment-heavy mutations needs oracles for connections, groupings, and synthesis we cannot yet manufacture
• Axes of artifact analysis (note) - Artifact analysis records retained behavior-shaping artifacts by storage substrate, representational form, lineage, and behavioral authority so review evidence, invalidation, and rollback follow how artifacts actually act
• Bottom-up structure inference needs capture at the decision surface, not the state (note) - Bottom-up inference of entities and relations from traces needs decision-shaped capture at the decision surface: the 'why' is cheap to record there and hard-to-impossible to recover from state later
• Bounded-context orchestration model (note) - Formalises agent orchestration as a symbolic scheduler driving bounded LLM calls through a select/call loop — explains why selection is hard while still supporting local strategy comparisons
• Brainstorming how to enrich web search (note) - Design exploration for enriching web search by reusing /connect's dual discovery and articulation testing on results, building a temporary research graph before bridging to KB
• Brainstorming: how explanatory-reach informs KB design (note) - Deutsch's reach, registered here as explanatory-reach, applied to KB notes — a maintenance risk signal, not a retrieval signal, because high-explanatory-reach revisions break downstream reasoning silently
• Brainstorming: how to test whether pairwise comparison can harden soft oracles (note) - Staged test plan for whether pairwise comparison improves soft-oracle properties (discrimination, stability, calibration) in LLM evaluation loops
• Brainstorming: maintainability oracles for agentic development (note) - Explores candidate signals, calibration experiments, authority levels, and workflow placements for evaluating maintainability in agent-generated code
• Capability placement should follow autonomy readiness (note) - Three tiers — skills (autonomous-ready), instructions (reusable-but-steered), methodology notes (exploratory) — keep AGENTS.md free of capability inventories with a clear promotion path
• Changing requirements conflate genuine change with disambiguation failure (note) - Separates world change from late discovery that downstream work chose the wrong interpretation of an underspecified requirement; short iterations mainly limit propagation of the latter
• Charting the knowledge-access problem beyond RAG (note) - Brainstorming note that decomposes the "how should an agent find what it needs?" problem into storage substrate, pointers, navigation, synthesis, and maintenance beyond RAG-vs-filesystem debates
• Choosing what to learn requires both validity and learning-value gates (note) - Separates two promotion checks for learning loops: whether a candidate is trustworthy enough to learn from, and whether learning it would improve the current system.
• Churning state on a many-to-many edge is where files yield to a database (note) - The clearest structural trigger for a files-first KB to adopt a relational store — churning state on an ownerless many-to-many edge; high churn alone, or static topology alone, stays in files
• Claim notes should use Toulmin-derived sections for structured argument (structured-claim) - Three independent threads converged on Toulmin's argument structure — adopting Toulmin sections as base type structured-claim separates claim-titled notes (any note) from fully argued claims (the type)
• Claw learning loops must improve action capacity, not just retrieval (note) - A Claw learning loop must target contextual competence (execution, classification, planning, communication), not just retrieval accuracy — question-answering is one mode among many
• Codification and relaxing navigate the bitter lesson boundary (note) - Since you can't identify which side of the bitter lesson boundary you're on until scale tests it, practical systems must codify and relax — with spec mining avoiding the vision-feature failure mode
• Codified scheduling patterns can turn tools into hidden schedulers (note) - As agent behavior matures, deterministic next-step policies need explicit control logic; if the framework offers only tools, scheduling patterns end up there and the tools become hidden schedulers
• Codify-versus-LLM decision heuristics (note) - Four lenses on the codify-vs-LLM decision — spec completeness, oracle strength, interpretation space, pattern stability — collected from across the KB, with evidence they come apart at the edges
• Commitment, not derivation, creates new ground truth (note) - Derivation — claims recoverable from the source, nothing added — leaves the source as ground truth; what adds unentailed resolutions becomes ground truth at commit, repaired by supersession
• Compiling a coordination strategy preserves primitive authority but expands aggregate authority (note) - Compiling a coordination strategy preserves the primitive action alphabet but expands aggregate authority — the single-context envelope it escapes bounded both compute and effect volume
• Computational model (tag-readme) - Tag README — PL concepts (scoping, homoiconicity, partial evaluation, typing) applied to LLM instructions, plus the scheduling architecture that follows from context scarcity
• Conjecture is seeing the particular as an instance of the general (note) - A conjecture posits a general concept while recognizing particulars as instances; the co-arising tightens with abstraction depth, from shared feature to generative model.
• constraining (tag-readme) - Curated head for the constraining tag — narrowing the interpretation space of artifacts, from conventions to deterministic code; codification, relaxing, and the decision heuristics
• Constraining and extraction can trade generality for reliability, speed, or cost (note) - Constraining narrows interpretation and extraction produces focused use-shaped artifacts; both can trade generality for reliability, speed, or cost when task fit is good
• Constraining during deployment is continuous learning (note) - Continuous learning can happen outside of weights; constraining is one symbolic-artifact form where prompts, schemas, tools, and tests accumulate durable adaptive capacity during deployment
• Context contamination operates below an agent's compliance reasoning (note) - A controlled test found fine-grained stance drift despite explicit detection and refusal; exclusion guarantees non-exposure, while instruction-level mitigation remains an empirical question
• Context efficiency is the central design concern in agent systems (note) - Context is the single scarce resource in agent systems, and it is scarce for two distinct reasons — per-window degradation (feasibility) and aggregate token economics (cost) — of which feasibility is the binding one
• Context engineering (tag-readme) - Index for context-engineering notes about selecting, scoping, and maintaining task-relevant knowledge under bounded context
• Continual learning's open problem is behaviour, not knowledge (note) - Continual learning's hard part is behaviour change; knowledge accumulation fits ordinary stores, while durable behaviour change comes through weights or readable artifacts
• Conversation vs prompt refinement in agent-to-agent coordination (note) - Conversation preserves the execution trace; prompt refinement compresses it into a clean handoff. The right choice depends on architecture and how much intermediate work should survive
• Convert still requires semantic description
• Criteria edits invalidate verdicts; process edits invalidate artifacts (note) - Editing an artifact's quality criteria invalidates verdicts (re-judge); editing its production process invalidates artifacts (regenerate) — a verdict is a cache keyed exactly on criteria
• Decomposition heuristics for bounded-context scheduling (note) - Working heuristics for symbolic scheduling over bounded LLM calls — separate selection from joint reasoning, choose representations not just subsets, save reusable intermediates in scheduler state
• Deploy-time learning is the missing middle (note) - Deploy-time learning fills the gap between slow distributed-parametric training and ephemeral in-context adaptation — durable system-definition artifacts updated across sessions during deployment
• deploy-time-learning (tag-readme) - Curated head for the deploy-time-learning tag — the framework of system adaptation through durable, inspectable artifacts, plus learning fundamentals and feedback quality
• Design for the first-time human, except on access cost (note) - Design heuristic for agent-consumed systems: treat agents like competent first-time humans except where linear context loading makes access costs diverge.
• Design proposals differ from claims in kind, not confidence (note) - Distinguishes hypotheses, which remain truth-apt at lower commitment, from designs judged by usefulness; substantive requirements can recast a design as an existential claim with a witness
• Designing a Memory System for LLM-Based Agents (note) - Derives agent-memory design pressures and links to a requirements inventory for agents designing or evaluating memory systems
• Deterministic validation should be a script (note) - Half of /validate's checks are hard-oracle (enums, link resolution, frontmatter structure) and could run as a Python script in milliseconds instead of burning LLM tokens via the skill
• Diagnostic richness constrains outer-loop learning quality (note) - Outer-loop learning depends on inspectable failure evidence, not only on the oracle used to select winning candidates
• Directory placement is total, frontmatter classification is partial (note) - Canonical paths cover every file before validation and supply locality; opt-in types supply portability. Validation can encode similar policy on either surface, but native guarantees differ.
• Directory-scoped types are cheaper than global types (note) - Global types tax every session's context; directory-scoped types load only when working in that directory — most structural affordances are directory-local, so the type system should match that economy
• discovery (tag-readme) - Curated head for the discovery tag — positing a general concept and recognizing particulars as its instances; explanatory-reach as the value of what discovery produces
• Document system (tag-readme) - Index of notes about document types, writing conventions, validation, and structural quality — how notes are classified, structured, and checked
• Document types should be verifiable (note) - Document types should assert verifiable structural properties, not subject matter — with a base type + traits model inspired by gradual and structural typing
• Elicitation requires maintained question-generation systems (note) - Four elicitation strategies ordered by user expertise required, composable into review architectures with maintenance loops that prevent ossification
• Enforcement without structured recovery is incomplete (note) - The enforcement gradient covers detection and blocking but has no recovery column — recovery strategies (corrective → fallback → escalation) are the missing layer, and oracle strength determines which are viable at each level
• Entropy management must scale with generation throughput (note) - In agent-maintained systems, cleanup throughput must match generation throughput — agents replicate existing patterns including bad ones, so without proportional maintenance, quality degrades as a function of output volume
• Ephemeral computation prevents accumulation (note) - Ephemeral computation — discarding generated artifacts after use — trades accumulation for simplicity, making it the inverse of codification
• Ephemerality is safe where embedded operational knowledge has low explanatory-reach (note) - Kirsch's barriers all mark cases where software carries decisions that must survive into future runs, users, and audits; ephemerality is safe only when that knowledge stays local
• Epiplexity by example: what entropy and complexity miss (note) - ELI5 explanation of epiplexity through encrypted messages, shuffled textbooks, CSPRNGs, and chess notation — contrasting surprise, shortest description, and observer-relative usable structure
• Error correction works with above-chance oracles and decorrelated checks (note) - Error correction for LLM output is viable whenever the oracle has discriminative power (TPR > FPR) and checks are decorrelated — amplification cost scales with 1/(TPR-FPR)² and independence of errors
• Error messages that teach are a constraining technique (note) - In agent systems the error channel is an instruction channel — making errors teach the fix is nearly free and eliminates the agent's need to diagnose, an orthogonal axis to enforcement strength
• Evaluation (tag-readme) - What works, what doesn't, what needs testing — empirical observations about KB operations and prompt design
• Evaluation automation is phase-gated by comprehension (note) - Optimization loops require manual error analysis and judge calibration before automation can improve behavior rather than just score
• Exact implementation does not validate a requirement against its objective (note) - An artifact can exactly implement a requirement while the requirement remains a conjectured proxy for a declared objective; assess each named path separately, and attribute failure to the link without erasing local correctness
• Execution indeterminism is a property of the sampling process (note) - The same prompt can produce different outputs across runs due to token sampling — this is a property of the execution engine, theoretically eliminable but practically ubiquitous, and often confused with the deeper issue of underspecification
• Execution shaping determines directory placement (note) - Hunch that artifacts shaped as executable procedures belong in kb/instructions/ — the directory boundary is execution form, not compression or loading frequency
• Failure modes (tag-readme) - Index for failure-modes notes about characteristic ways knowledge can exist without changing agent behavior
• False-positive generation is filtered; false-positive acceptance becomes operative (note) - False-positive generation faces evaluation before retention, while false-positive acceptance becomes operative and can compound
• Feedback-trained memory management is oracle-dependent even when its operations are hand-designed (note) - Fixed and merely runtime-responsive memory rules need no training oracle; outcome-driven updates do, while noisy rankings weaken learning and misaligned ones teach the wrong ordering
• Files beat a database for agent-operated knowledge bases (note) - Files beat a database early on — a schema commits to access patterns before you know them, and files let you constrain incrementally while getting free browsing, versioning, and agent access from day one
• First principles are inherited constraints, not design choices (note) - A rule is a first principle iff it arrives in the constraint packet of a boundary commitment (consumer, substrate, domain, machinery); packets cannot be cherry-picked, so these cannot demote
• First-principles reasoning selects for explanatory-reach over adaptive fit (note) - Adapts Deutsch's adaptive-vs-explanatory distinction to KB design — first-principles reasoning selects explanations with explanatory-reach, accountable to observed fit and rival-practice tests
• Flat memory predicts specific cross-contamination failures that are empirically testable (note) - Flat memory predicts three cross-contamination failures — search pollution, identity scatter, insight trapping — testable via an observation protocol against real agent systems
• Formal symbolic systems assess explanatory-reach only through causal and proof obligations (note) - Formal symbolic systems assess explanatory-reach only after claimed generality is translated into causal or proof obligations inside a warranted model
• Foundations (tag-readme) - Core theory the rest of the KB builds on — contextual competence, bounded context, explanatory-reach, design methodology, composability
• Frontloading is partial evaluation, not divide-and-conquer (note) - The partial-evaluation framing for LLM frontloading is structurally precise, not metaphorical, because LLM context is a homoiconic medium; without homoiconicity, it would just be divide-and-conquer
• Frontloading spares execution context (note) - Pre-computing known instruction inputs and inserting their results spares execution-context budget inside a later LLM call
• Full-identity keys decouple a batch protocol from its packing axis (note) - A batched LLM-call protocol keyed by each unit's full composite identity, not position or a single axis, lets grouping strategy vary freely without protocol change
• Generality bought to avoid counterexamples is paid for in precision (note) - Widening a claim's vocabulary to survive counterexamples raises universality by spending precision, so content stays flat — and the unreadability that follows is the symptom, not the price of rigor
• Generate KB skills at build time, don't parameterise them (note) - Template generation pays the flexibility cost once at setup; runtime variables pay it on every use across every substitution site, with occasional LLM misreads
• Gödel machines are a proof-governed case of reflective self-modification (note) - The Gödel machine realizes reflective self-modification with a proof-gated acceptance rule, gaining model-relative rigor at the cost of excluding useful changes it cannot prove
• History has one chance to become checkable (note) - An artifact's production history is convertible to later-checkable form only at production time, via records/attestation or re-derivability; after that a bounded reviewer sees only carried state
• Human writing structures transfer to LLMs because failure modes overlap (note) - Writing genres evolved to prevent reasoning failures; the same structures help LLMs because they share those failure modes (content effects on reasoning) — evaluated per convention, not by analogy
• Human-LLM differences are load-bearing for knowledge system design (note) - Knowledge systems both inherit human-oriented materials and produce dual-audience documents (human + LLM), making human-LLM cognitive differences a first-class design concern rather than a generic disclaimer
• Improving an agentic system crosses the natural-language/symbolic boundary (note) - The error-correction asymmetry sorts agentic behavior between natural-language and code, so reliability-improving changes cross the boundary; reflective coverage of one form cannot carry them
• In-context learning presupposes context engineering (note) - In-context learning only works when the right knowledge reaches the context window — the selection machinery that ensures this is itself learned and refined over deployment
• Inbound and outbound links serve asymmetric reader needs (note) - Outbound links are authored reader aids; their on-demand inverse serves distinct standing, grounding, impact, and tension needs without forbidding independently useful reciprocal links
• Increasing computational autonomy relocates human effort to the frontier instead of reducing it (note) - In an open-ended system, increasing computational autonomy need not cut total human hours — attention moves to the frontier — so measure improvements per human judgment, not human time
• Index curation adds orientation that generation cannot produce (structured-claim) - Generated indexes guarantee completeness but not orientation — curation adds editorial grouping and context phrases that turn a listing into a navigable map
• Indirection is costly in LLM instructions (note) - In code, indirection (variables, config, abstraction layers) is nearly free at runtime — in LLM instructions, every layer of indirection costs context and interpretation overhead on every read
• Information value is observer-relative (note) - Information value is observer-relative: prior knowledge, tools, compute, and goals determine extractable structure, grounding use-shaped reshaping and discovery.
• Inspectable artifact, not supervision, defeats the blackbox problem (note) - Chollet frames agentic coding as ML producing blackbox codebases — codification counters this not by requiring human review but by choosing readable artifacts (code, prompts, schemas) that any agent can inspect, diff, test, and verify
• Instruction specificity should match loading frequency (note) - The loading hierarchy (CLAUDE.md → skill descriptions → skill bodies → task docs) should match instruction specificity to loading frequency — always-loaded context competes for attention every session
• Instructions are typed callables with document type signatures (note) - Skills and tasks are typed callables — they accept document types as input and produce types as output, and should declare their signatures like functions declare parameter types.
• Interpretation errors are failures of the interpreter (note) - Real LLMs produce outputs that no valid interpretation of the spec allows — violating explicit constraints, hallucinating, failing at fully specified bookkeeping — a property of the interpreter itself, absent from the idealised two-phenomena model
• KB goals in always-loaded context guide inclusion decisions (note) - Without explicit goals in the always-loaded control-plane file, agents cannot reject well-written but off-scope material — a universal quality guide provides writing criteria but not domain scope
• KB maintenance (tag-readme) - Index of notes about keeping the KB healthy over time — detection of staleness and quality degradation, maintenance operations, and the dynamics that govern system entropy
• Knowledge storage does not imply contextual activation (note) - Separates knowledge that exists, knowledge loaded into context (read-back), and knowledge that actually changes behavior (activation); explains why retrieval and long context do not guarantee activation
• Known-target discovery benchmarks show reachability, not discovery closure (note) - Distinguishes backcast and reinvention benchmarks from autonomous discovery: they show that target insights are reachable from supplied ingredients, not that a system can select and verify new discoveries prospectively.
• Learning inside a fixed decomposition inherits its mistakes (note) - Why optimization cannot repair consequential distinctions, responses, or mappings outside the effective update space of a fixed task decomposition
• Learning is not only about generality (note) - Per Simon, any capacity change is learning; accumulation is the basic operation, explanatory-reach its key property (facts low, theories high); capacity splits into generality vs reliability/speed/cost
• Learning theory (tag-readme) - Curated head for the learning-theory tag — how systems learn, verify, and improve; routes to the covered child tags listed in covered_by.
• Legal drafting solves the same problem as context engineering (note) - Legal drafting parallels context engineering because both write ambiguous natural-language specifications for judgment-based interpreters, but law develops constraining more than codification
• Link graph plus timestamps enables make-like staleness detection (note) - Existing links already encode dependency information; comparing note and target timestamps flags notes that may be stale without any new annotation, analogous to make's file-based rebuild logic.
• Link strength is encoded in position and prose (note) - Not all links are equal — inline premise links ("since [X]") carry more weight than footer "related" links. Position and prose encode commitment level, creating a weighted graph that affects traversal, scoring, and quality signals.
• Link-following and search impose different metadata requirements (note) - Link-following is local with rich context; search is long-range with only titles/descriptions — each mode imposes different metadata requirements on the knowledge system
• Linking theory (note) - Links are decision points; link quality is the reduction of navigation uncertainty per token of context consumed. Grounds our relationship vocabulary, title-as-claim, and position-encodes-strength practices under one model.
• Links (tag-readme) - Index of notes about linking — how links work as decision points, navigation modes, link contracts, and automated link management
• Links encode conditional possibilities, not obligations (note) - Links encode conditional possibilities, not obligations — every label must name a specific reader-need (the condition under which following pays off); content required for all reachable readers should be inlined, not linked
• LLM context is a homoiconic medium (note) - Instructions and data share one token representation in an LLM context, enabling natural-language extensibility while creating Lisp-like contamination and scoping hazards
• LLM context is composed without scoping (note) - Flat context concatenation lacks local scope and produces name collision, contamination, and spooky action at a distance; code-built sub-agent contexts must impose boundaries
• LLM debugging starts with retry-versus-rewrite triage (note) - Uses execution-versus-interpretation failure to choose the first debugging move: retry a bad execution of a sound reading, or rewrite a specification that reliably induces the wrong reading
• LLM frameworks should keep the tool loop optional (note) - Framework-owned tool loops package the common model/tool/retry pattern well, but strong frameworks keep the loop optional so applications can control state projection, branching, and re-entry
• LLM generation relaxes a goal it can't satisfy and hides the constraint a human writer stalls on (note) - A human writer stalls at the constraint they can't satisfy; an LLM instead ships fluent output that looks solved but silently drops it — hiding the error, so the check falls on the reader
• LLM interpretation errors (tag-readme) - Three sources of deviation between intended and actual LLM output — prompt underspecification, execution indeterminism, and interpreter failure — plus oracle theory, error correction, and architectural responses for managing each
• LLM learning phases fall between human learning modes rather than mapping onto them (note) - Pre-training acquires both structural priors (evolution's role in humans) and world knowledge in one pass — making it and in-context learning intermediate on the evolution-to-reaction spectrum
• LLM recompute cost inverts the store-vs-recompute default (note) - For an LLM consumer, in-context recompute is the expensive step, so materializing a derived value to be read pays off exactly where storing it would be premature denormalization in code
• LLM-executed methodologies are metacircular interpreters, not compilers (note) - Self-hosting LLM methodologies are closer to metacircular interpreters than compilers: agents re-interpret natural-language rules each session, while stable paths codify into validators and commands
• LLM-mediated schedulers are a degraded variant of the clean model (note) - When the agent scheduler lives inside an LLM conversation it becomes bounded and degrades; three recovery strategies — compaction, externalisation, factoring into code — restore the clean separation to increasing degrees
• LLM↔code boundaries are natural checkpoints (note) - At each LLM↔code transition both semantic underspecification and execution indeterminism collapse simultaneously, making these boundaries natural places to anchor debugging, testing, and refactoring
• Load-bearing vocabulary collisions should be prevented or visibly scoped at write time (note) - Unqualified technical senses have no reliable namespace in natural-language content; schema slots, rare compounds, and linked clause frames scope them at write time; audits and remediation recover when prevention fails
• Localized retention pays when sparse changes have bounded impact in a matching decomposition (note) - Addressable retention localizes a sparse change when units match its decomposition; total adaptation stays local only when the affected units also have a small, explicit impact closure
• Machinery persists by warrant, not position, in a reflective loop (note) - Sutton's build-mode assumes a meta-method outside the learned system, exempt from selection by position. A reflective loop has no outside: machinery is artifacts in loop scope, the boundary moves per artifact, and persistence must be earned
• Maintenance operations catalogue should stage stable procedures for instructions (note) - Catalogue of periodic KB maintenance operations and readiness status, used as a staging ground before promotion into kb/instructions procedures
• MCP bundles stateless tools with a stateful runtime (note) - MCP forces stateless tool operations through a persistent server process — most tools are pure functions that don't need session state, connections, or lifecycle management, but pay the complexity tax anyway
• Measuring autonomy well enough to see it improve is an open problem (note) - Autonomy is reported per function rather than scored as a percentage, but that profile does not yet support comparison across systems or time
• Mechanistic constraints make Popperian KB recommendations actionable (note) - Bounded context and underspecification don't just permit conjecture-and-refutation — they require it; derives three concrete practices (falsifier blocks, contradiction-first connection, rejected-interpretation capture) from KB mechanics.
• Memory design adds operational axes to artifact analysis (note) - Memory design needs operational policy axes (capture, derivation, activation, authority assignment, lifecycle, evaluation) on top of substrate, form, lineage, and behavioral authority
• Methodological and computational closure track different changes (note) - Methodological closure tracks whether a retained method settles consequential decisions; computational closure tracks whether those decisions require a human actor
• Methodology enforcement is constraining (note) - Places instructions, skills, hooks, and scripts on a gradient from model-interpreted guidance to deterministic execution, with hooks combining fixed triggers and semantic responses
• Methodology with incomplete coverage and its live theory fallback form a two-layer execution system (note) - In open or incompletely covered domains, the theory-derived fast path and live theory fallback co-execute while methodology-native content follows a separate maintenance regime
• Minimum viable vocabulary is the naming set that most reduces extraction cost for a bounded observer (note) - Defines minimum viable vocabulary as the names that most reduce a bounded observer's extraction cost, connecting conceptual thresholds to an information-theoretic optimization
• Natural-language content lacks reliable dereference, so facts need reinforcement at point of use (note) - Code dereferences a name everywhere; LLM-read natural language does not, so a fact stated once may not govern distant uses — reinforce it at each point of use and check copies for drift
• Notes need quality scores to scale curation (note) - As the KB grows, /connect will retrieve too many candidates — evidence, type, inbound links, recency, and link strength can rank what is worth evaluating
• Observability (tag-readme) - Index of notes about making hidden state, hidden failure, and quality drift visible — runtime inspectability, degraded-execution signals, and maintenance-oriented detection mechanisms
• Only derivation and inheritance warrant a decomposition's scope claim; discriminating use earns it (note) - Derivation from supported constraints and inheritance of a source-tested ontology give a decomposition conditional or transferred starting warrant; free choice gives only a pragmatic reason to adopt, and only refutation-capable use earns the claim
• Only explicit retention is currently durable, writable, and addressable at once (note) - Every tacit retention form — in-context conditioning, weights under selection or fine-tuning, human expertise — fails addressability, so governed retention currently runs through explicit artifacts
• Opacity is a scale threshold, not a class property (note) - Opacity is not a representational form; any representation becomes practically opaque at sufficient scale, though distributed-parametric artifacts cross that threshold earliest.
• Open-domain memory retention needs a declared output spec (note) - Explains why an input stream alone can't answer 'what to store' in open-domain memory design; a declared output spec supplies the missing inclusion criterion.
• Operational signals that a component is a relaxing candidate (note) - Operational signals for when a component likely encodes a brittle proxy theory rather than an exact specification and should be relaxed instead of codified harder
• Oracle accumulation improves selection for later candidates in its maintained domain (note) - A failure retained as a lesson helps tasks that retrieve it; retained as a maintained check it improves selection for later candidates in its domain and amortizes validation
• Oracle strength spectrum (note) - Exploratory framework — oracle strength, how cheaply correctness can be verified, as the gradient underlying the exact-spec/proxy-theory distinction, with an oracle-hardening pipeline
• Orchestration strategies and run-state have opposite persistence economics (note) - Separates ephemeral task-specific run state from reusable selection strategies inside host schedulers; RLM-style execution discards both and therefore loses the valuable reusable half
• Parametric reproduction alone cannot replace an authoritative record (note) - Reproducing a record's content does not transfer its authority. Replacement requires a governed artifact with stable identity, integrity, contestability, and attribution; mutable records also require currentness and addressable revision.
• Periodic KB hygiene should be externally triggered, not embedded in routing (note) - Routing instructions serve the current task; periodic hygiene is triggered externally (user, heartbeat, CI), so embedding it in always-loaded routing blurs two responsibilities and adds session noise
• Pointer design tradeoffs in progressive disclosure (note) - Compares fixed, query-time, and crafted retrieval pointers across specificity, precomputation cost, reliability, and authoring dependence to explain when each progressive-disclosure form pays
• Process structure and output structure are independent levers (note) - Distinguishes constraints on reasoning steps from constraints on result shape, using code-reasoning and GSM-DC evidence where process structure changes outcomes beyond formatting
• Programming patterns get a fast pass but other borrowed ideas must earn first-principles support (note) - We borrow from any source but adopt based on first-principles support — except programming patterns, which get a fast pass because the bet is that knowledge bases are a new kind of software system
• Progressive constraining commits only after patterns stabilize (note) - Constraining via LLM code generation freezes a single projection of the spec in one shot, but progressive constraining observes behavior across many runs and commits only the interpretations that consistently emerge
• Promotion selects for unreliable activation, and the regress ends only at an external trigger (note) - Recasts the retention criterion from 'the consumer lacks this' to 'the consumer will not apply this unprompted', and argues a promoted conclusion stays unfinished until its trigger bottoms out outside the retained-artifact chain
• Prompt ablation converts human insight into deployable agent framing (note) - Methodology for testing prompt framings — uses controlled variation against a human-verified finding to identify which cognitive moves agents can reliably execute, then deploys the winning framing as instruction
• Psychology-to-agent transfer needs per-principle failure-mode testing (note) - Brainstorming a methodology for evaluating cognitive-science-to-agent transfer — assembled from three existing KB notes and tested against Youssef's five psychology principles as worked examples
• Quality signals for KB evaluation (note) - Catalogues graph-topology, content-proxy, and LLM-hybrid signals that could be combined into a weak composite oracle to drive a mutation-based KB learning loop without requiring usage data.
• Raw accumulation does not create usable memory (note) - Accumulation preserves material, but usable agent memory requires ingress work that adds handles, scope, relationships, provenance, trust signals, and lifecycle pressure.
• Real self-improving systems occupy combinations no single rung captures (note) - Casebook of eight placements on selected pathway-profile fields — Homeostat to Commonplace — reflection, cumulativity, allocation, and evidential limit in combinations no rung expresses
• Reasoning production is not reasoning evaluation (note) - Review and critique systems need independent process-validity checks because a model can substitute answer reconstruction for reasoning evaluation
• Reflection buys addressability (note) - Self-improvement can compound without reflection — parametric learners do — but non-reflective retention gives only indirect handles; reflective retention makes the changed object addressable
• Reflection makes retained lessons second-order: a lesson can reject or rescope a prior commitment (note) - Reflection lets a retained lesson target a prior commitment explicitly — rejecting, revising, or rescoping it — while non-reflective correction acts indirectly through the substrate
• Reflective coverage is graded across representational forms (note) - Reflective coverage is graded per representational form and operation profile; selection among opaque components — pinning a model — is real but selection-only coverage of the parametric form
• Reliability dimensions map to oracle-hardening stages (note) - The four reliability dimensions from Rabanser et al. (consistency, robustness, predictability, safety) each harden a different oracle question — mapping empirical agent evaluation onto the oracle-strength spectrum
• Retaining the episode keeps a distilled rule re-derivable (note) - The episode a lesson was learned in and the rule distilled from it are complementary retention layers: with the episode retained and lineage recorded the rule stays evidence-backed and re-derivable; without it the rule hardens into a bare commitment
• Retrieval failure is reflection failure (note) - Where a self-representation is retained artifacts, retrieval is the wire it acts along — a search that misses a represented constraint breaks the causal connection, not just convenience
• Reverse compression is when LLM output expands without adding information (note) - LLMs can inflate compact seeds into verbose artifacts without adding extractable structure; a KB resists this only when links add epiplexity
• Review automation should target verifiable subroles before reviewer identity (note) - Scholarly-review automation should decompose reviewer work into separately verifiable subroles before giving an AI system reviewer-level authority
• Revising an improvement objective is licensed from outside it or is not improvement (note) - Objective change is improvement only against a level outside both objectives; proxy revision, re-indexing, and surfaced under-specification subtract most apparent cases
• RLM has the model write ephemeral orchestrators over sub-agents (note) - RLM packs orchestration over sub-agents into the tool-loop model by having the model write orchestrators in a REPL — elegant but ephemeral because the orchestrators are discarded after each run
• RLM, Tendril, and llm-do place symbolic work at different persistence boundaries (note) - Compares RLM variants, Tendril, and llm-do as placements for symbolic work and interfaces: ephemeral REPL code, typed RLM combinators, workspace-local generated tools, and durable unified callables
• Runtime structure determines the control surfaces available to governance (note) - Runtime structure and runtime governance are separable, but the runtime's structure determines which inspection, validation, correction, and drift-control operations governance can actually perform
• Scaling absorbs scaffolding at fixed task difficulty, not at the deployment frontier (note) - Stronger models shrink the scaffolding a fixed task needs; durable deployment-specific structure recurs at the frontier only while assigned difficulty keeps pace with capability and some reliability function stays advantageous to externalize
• Scenario decomposition drives architecture (note) - Deriving architectural requirements by decomposing concrete user stories into step-by-step context needs — not from abstract read/write operations but from what the agent actually has to load at each stage
• Scheduler-LLM separation exploits an error-correction asymmetry (note) - Symbolic bookkeeping eliminates underspecification, indeterminism, and bias relative to the implemented transition function; semantic work faces all three. Mixing forces exact state onto an expensive substrate; codification renegotiates the boundary
• Selective revision needs a faithful rationale, not just a legible one (note) - Revision reaches the premise that broke only through the theory's recorded rationale, so a readable but unfaithful rationale makes repair confidently wrong rather than merely uninformed
• Self-improvement is relative to a declared objective (note) - The improvement objective is a declared parameter alongside boundary and horizon, carrying two separable conditions — indexed by the analyst, antecedent in the pathway — whose failures differ in kind
• Self-improving systems (tag-readme) - Curated head for the self-improving-systems tag — membership, update architecture, and the four-part pathway profile; selective picks
• Semantic review catches content errors that structural validation cannot (note) - Structural validation catches form errors; semantic review catches content errors like incomplete enumerations, grounding drift, boundary-case gaps, and internal contradictions
• Semantic sub-goals that exceed one context window become scheduling problems (note) - Some semantic subgoals exceed one context window, so they must be partitioned into smaller semantic judgments with symbolic collection, filtering, and staged summarization between them
• Session history should not be the default next context (note) - Storing execution history and loading it into the next agent call are separate decisions; chat and framework-owned tool loops conflate them by making session history the default next context
• Short composable notes maximize combinatorial discovery (note) - The library's purpose is to produce notes that can be co-loaded for combinatorial discovery — short atomic notes are a consequence of this goal; longer synthesized artifacts belong in workshops or derived instructions
• Silent disambiguation is the semantic analogue of tool fallback (note) - When an agent silently resolves unacknowledged material ambiguity in a spec, final success hides that the contract failed to determine the path — an extension of the tool-fallback observability problem
• Skill discovery re-fires in every sub-agent context, not just the top-level invocation (structured-claim) - Skill discovery is per-context and autonomous — every installed skill is re-matched in each sub-agent context, even ones a parent narrowed, so a delegating skill's own discoverability is a leak vector
• Skills are instructions plus routing and execution policy (note) - Skills add structured discovery, user-facing invocation, and declarative execution policy (tool permissions, model override, context isolation) beyond the shared procedure
• Skills derive from methodology (structured-claim) - The methodology→skill relationship is same-medium derivation, with the methodology retained as live fallback — distinct from codification and constraining
• Soft-bound traditions as sources for context engineering strategies (note) - Survey of twelve soft-bound traditions as candidate sources for context engineering strategies, with a three-tier assessment of what transfers, what's plausible, and what's blocked
• Solve low-degree-of-freedom subproblems first to avoid blocking better designs (note) - Ordering heuristic for decomposition: commit first to decisions with the fewest viable options, then place flexible choices around them to preserve global optionality.
• Source changes should surface downstream review targets, while reverse lineage can remain searchable (note) - Source-dependent artifacts need lineage signals when an upstream change may render those artifacts stale, regardless of where the lineage record is stored
• Spec mining is codification's operational mechanism (note) - Operationalizes codification by extracting deterministic verifiers from observed stochastic behavior — the mechanism that converts blurry-zone components into calculators
• Specification strategy should follow where understanding lives (note) - Among durable artifacts, spec-first, bidirectional spec, and spec mining fit different phases: when understanding is available upfront, discovered during execution, or only visible after observation
• Specification-level separation recovers scoping before it recovers error correction (note) - OpenProse-like DSLs expose control flow and discretion boundaries while leaving scheduling and validation on the LLM substrate, creating an intermediate regime between flat prompting and symbolic scheduling
• Stale indexes are worse than no indexes (note) - An agent trusts an index as exhaustive — a missing entry doesn't trigger search, it makes the note invisible
• Stale self-description conceals its own staleness (note) - What artifact drift adds when it is reflexive: the process that would detect it consults the artifact that drifted, the trigger has no edit event to hook, and synchronization load scales with autonomy
• Stateful tools recover control by becoming hidden schedulers (note) - Granting the strongest stateful-tool escape hatch shows that recovered control comes from relocating the scheduler into an exceptional tool or runtime, not from the framework loop itself
• Storing LLM outputs is constraining (note) - Keeping a specific LLM output resolves semantic underspecification and freezes one run against execution indeterminism - a constraining move applied to artifacts
• Structure activates higher-quality training distributions (note) - Structured templates like Evidence/Reasoning sections steer autoregressive generation toward higher-quality training data (scientific papers, legal analyses) rather than unstructured web text — the structure acts as a distribution selector
• Structured output is easier for humans to review (note) - Separated Evidence and Reasoning sections let human reviewers check facts and logic independently — a purely readability argument that doesn't depend on LLM behavior at all
• Subtasks that need different tools force loop exposure in agent frameworks (note) - When decomposition creates child tasks with different tool surfaces, the parent must construct fresh calls for each child, so a framework-owned loop is no longer the right control surface
• Symbolic context engineering is bounded by symbol availability (note) - Derives the availability limit of symbolic routing: type, path, tag, tool, or event selectors can react only after a usable symbol is declared, named by an operation, or carried forward
• Synthesis is not error correction (note) - Synthesis propagates errors by merging all agent outputs; voting corrects errors by discarding minorities — Kim et al.'s 17.2× amplification is a synthesis failure, not evidence against multi-agent coordination
• System-definition artifacts are crystallized reasoning under context scarcity (note) - Separates heuristic rules that substitute for unavailable read-time reasoning from authority-bearing constraints and symbolic codification, which remain useful even with abundant context
• Systematic prompt variation serves verification and diagnosis, not explanatory-reach testing (note) - Controlled prompt variation either decorrelates checks or measures brittleness under fixed task semantics; Deutsch's variation test instead changes the explanation to test mechanism and explanatory-reach
• Tags (tag-readme) - Hub for all tag READMEs — browse the KB by conceptual domain rather than by directory; complete over the tag pages in this collection
• Task-fitted structure costs cross-task reuse (note) - Structure fitted to the questions a KB is asked today loses value when the questions change; wikis accumulate the damage because structure is cheap to add and nothing forces its removal
• Technical constraints turn KB objective-function choice from philosophy into engineering (note) - Four technical constraints make KB objective-function choice testable engineering, not philosophy; goals set the loss, contracts and profiles specialize it, and oracle strength differs per profile
• Text testing framework — source material
• The augmentation-automation boundary is discrimination not accuracy (note) - Crossing from augmentation to automation requires per-instance discrimination, not aggregate accuracy — discrimination is empirically stagnant, so scaling capability alone cannot cross the boundary
• The bitter lesson selects against unearned reach, not against structure (note) - Scale replaces generalizations whose claimed scope was asserted from source-case fit rather than tested; structure whose reach was earned is what a scalable search converges on
• The bitter lesson selects production methods, not representational forms (note) - The lesson's axis is production method — hand-crafted versus search-and-learning — not representational form. Learned localized forms are therefore a coherent scaling hypothesis, with cross-artifact credit assignment as the decisive open problem
• The bitter-lesson defense portfolio has one load-bearing member for the form-only rebuttal (note) - The KB's bitter-lesson claims play different roles: one narrow answer to a form-only objection, an empirical burden, methodology, instrumentation, separate-objection answers, and conditional forecasts
• The boundary of automation is the boundary of verification (note) - Synthesis — oracle theory, labor economics, frontier-lab capability predictions, and supply-chain integrity evidence converge on verification cost as the primary structural determinant of automation
• The chat-history model trades context efficiency for implementation simplicity (note) - Chat history persists because appending messages preserves information and avoids interface design, but that convenience trades away selective loading under bounded context
• The four-field record exposes an efficiency, security, and sovereignty risk triad (note) - The four artifact-analysis fields exist to surface three architectural review concerns over retained behavior — efficiency, security, and sovereignty — with sovereignty (owner control to inspect, regenerate, delete, roll back) as the new axis
• The framework is often larger than the durable contribution (note) - Agents reproduce active framework content, but the durable contribution is usually the recognition that the situation fits the framework; default to minimal prose plus a framework link
• The Meta-Harness ablation does not identify episode-backed theory formation (note) - Why the summaries-hurt ablation does not identify the effect of scoped theory formation alongside retained episodes, while still supplying adverse evidence about condensed feedback
• The practical scheduler is the host language, not a reified select (note) - The simplest practical orchestration library demotes the tool loop to a returning, per-call-parameterized function and lets ordinary host-language code play select and K — reifying K only when the run must outlive its process or outgrow its memory
• The readable-artifact loop is the tractable unit for continual learning (note) - Identifies the natural-language-plus-symbolic pair as the tractable first loop for representational-form coevolution because it shares context, operates at current tempos, and already has a codification boundary
• The self-improving-system definition classifies its boundary cases without ad hoc exceptions (note) - Ten boundary cases run against the self-improving-system definition — each classifies by the stated criteria alone; the stress they apply falls on boundary declaration, not on the membership clauses
• The verifiability gradient (note) - Symbolic artifacts sit on a gradient from loose natural-language to deterministic code; higher-verifiability artifacts support tighter iteration loops, and learning moves artifacts along it in both directions
• The wikiwiki principle: lowest-friction capture, then progressive refinement in place (note) - Ward Cunningham's wiki design principle — minimize capture friction, refine in place — drives the text→note→structured-claim codification ladder
• Theory-mediated learning may improve sample efficiency under structured shifts (note) - Conjecture: learning that discovers, assesses, and revises addressable theories may need fewer target observations when a shift preserves the structure a theory names
• Theory-mediated self-improvement needs both interpretation and retention from one substrate (note) - Reflective self-improvement inherits the theory-mediated sample-efficiency conjecture only where one substrate both interprets a theory about the system's own operation and retains it addressably
• Three-space agent memory echoes Tulving's taxonomy but the analogy may be decorative (note) - The value of separating knowledge, self, and operational memory is that each has a different lifecycle — accumulation, slow evolution, and high churn; whether the Tulving mapping adds explanatory power beyond different retention policies is open
• Title as claim enables traversal as reasoning (note) - When note titles are claims rather than topics, following links between them reads as a chain of reasoning — the file tree becomes a scan of arguments, and link semantics (since, because, but) encode relationship types
• Title as claim exposes commitments, enabling Popperian maintenance (note) - When an index is a list of claims rather than topics, reviewing the KB becomes scanning hypotheses — each title exposes its commitment and invites the question "do I still believe this?" without opening the file
• Title as claim makes overlap between notes visible (note) - When note titles are claims, overlap between notes is visible at the index level — similar assertions are obvious without opening files; topical titles hide overlap behind different labels for the same territory
• Tool loop (tag-readme) - Index for the tool-loop argument — the framework-owned tool loop is useful but should yield control when tasks need different tool surfaces, exceed one context window, or codify scheduling
• Topology, isolation, and verification form a causal chain for reliable agent scaling (note) - Topology, isolation, and verification may form a strict dependency chain rather than independent design choices — tested against the simpler account that good decomposition implies the other two
• Trace-extracted memory earns authority per operation, not at capture (note) - Trace memories begin as records; verification, abstraction, and consultation earn authority under progressively harder oracles, while unverified stores accumulate guesses presented as knowledge
• Traditional debugging intuitions break when tool loops can recover semantically (note) - Programmers trained on traditional software expect broken infrastructure to fail loudly; semantic recovery in agent tool loops violates that expectation, so successful outcomes can create false confidence during debugging and maintenance
• Traversal improvements should be deferred via logging to avoid mid-task context switching (note) - Loading writing methodology into an already-committed context window is expensive; a one-line log entry preserves the improvement signal at near-zero cost and lets a separate pass do the fix
• Treat continual learning as representational-form coevolution (note) - Behaviour change spans distributed-parametric, natural-language, and symbolic forms, so the question is how their improvement loops relate — not which is the real locus of learning
• Two context boundaries govern collection operations (note) - Distinguishes the body-loading boundary from the later title-and-description index boundary, yielding three collection-size regimes with different consequences for areas, connect, and whole-KB work
• Type system (tag-readme) - Index of notes about the document type system — why types exist, what roles they serve, how they improve output quality, and how they're structured
• Type system enforces metadata that navigation depends on (note) - Descriptions don't appear spontaneously — they exist because the note base type requires them; without enforcement, metadata degrades and navigation collapses to opening every document
• Types give agents structural hints before opening documents (note) - Types and descriptions let agents make routing decisions without loading full documents — the type says what operations a document affords, the description filters among instances of that type
• Under sub-agent decomposition, feasibility is the heaviest fork's net load (note) - Shows why decomposition changes feasibility from total operation cost to the largest residual load left on any fork after work is shifted to siblings or the parent
• Underspecification and indeterminism complicate programming for prompts in distinct ways (note) - Indeterminism doubles test runs (statistical testing over distributions); underspecification doubles test targets (spec analysis for ambiguity). Conflating the two leads to misdiagnosis
• Unified calling conventions enable bidirectional refactoring between neural and symbolic (note) - When agents and tools share a calling convention, components can move between neural and symbolic without changing call sites — llm-do demonstrates this with name-based dispatch over a hybrid VM
• Unit testing LLM instructions requires mocking the tool boundary (note) - Skills are programs whose I/O boundary is tool calls — mocking that boundary creates controlled environments for testing whether instructions produce correct behavior, complementing text artifact testing with instruction-level regression detection
• Use tests a decomposition locally; retained rationale is what makes transfer testable (note) - Running a decomposition confirms only that it sufficed here; because many force-sets fit the same split, rationale retained at design time is what gives a transfer claim an antecedent to test
• Verification needs a typed target before it needs an oracle (note) - A check's warrant depends on a declared target class, so an unverifiable heterogeneous layer is usually blocked by missing artifact classification, not oracle difficulty — ontology precedes oracle
• Vibe-noting (note) - Vibe coding works because code is inspectable, not just verifiable — a KB adds that same inspectability to knowledge work, enabling augmentation even where automation is blocked on oracle construction
• Warranted autonomy is bounded by oracle domain (note) - Bare autonomy is free, but warranted evaluation autonomy extends only to the candidates an oracle can assess with the required confidence
• Weakly discriminated qualities tend to be underselected (note) - Conjecture separating available model capability from selection: qualities weakly distinguished by the actual acceptance oracle lose to strongly verified objectives
• Why directories despite their costs (note) - Directories buy one–two orders of magnitude of human-navigable scale over flat files, and enable local conventions per subsystem — but each new directory taxes routing, search config, skills, and cross-directory linking
• Why notes have types (note) - Seven roles of the type system — navigation hints, metadata enforcement, verifiable structure, local extensibility, content-layer identification, output quality through structured writing discipline, and maturation through constraining
• World models assess explanatory-reach through action-conditioned prediction (note) - Learned world models can assess explanatory-reach when action-conditioned predictions are tested across the interventions or shifts a commitment claims
• Writing conventions for kb/notes/ (theoretical profile)
• Writing styles are strategies for managing underspecification (note) - Maps descriptive, prescriptive, prohibitive, explanatory, and conditional context-file styles to distinct ways of narrowing agent interpretation, each trading constraint against generality