Three systems that did not survive the first overloaded week
The first learning system was a calendar. Review sessions were scheduled on fixed days. The logic was sound: regular review prevents decay, so schedule regular review. The system worked for approximately three weeks. The first week with a compressed deadline, the review sessions were skipped. The second compressed week, they were skipped again. By the third week, the calendar slots had accumulated enough backlog that catching up felt impossible, and the system was effectively abandoned — not explicitly, but through consistent non-use. A system that breaks on the first week of pressure is not a system. It is a plan.
The second failure was the capability ledger format. The first ledger tracked capability as a percentage: 85% confident in transformer architecture, 60% confident in RLHF, 90% confident in RAG pipeline design. The numbers felt like information. They were not. There was no calibration basis — the percentages were self-assessed estimates with no connection to external evidence. Over time the ledger drifted toward optimism: skills that had been reviewed once registered at high confidence levels that were not revisited as the underlying knowledge aged. The ledger looked healthy. The capability it represented was not.
The third failure was the curriculum structure. The first curriculum was a flat list of topics — no ordering, no dependencies, no blocking relationships. The practitioner worked through topics in order of interest, which felt productive. The failure became visible at application time: attempting to apply a skill that depended on three others that had been skipped produced confusion that could not be resolved without first addressing the prerequisites. The curriculum had no mechanism for making invisible dependencies visible. Every blocked skill looked like a motivation problem rather than a prerequisite problem.
The operational case — compounding capability as infrastructure
The case for learning infrastructure is the same as the case for any other personal infrastructure: manual alternatives do not scale. A practitioner can manage a small skill set manually — remembering what to review, maintaining an informal sense of which skills are stable and which are at risk. Past a certain breadth and depth, manual management fails silently. Skills decay without the decay being noticed. Prerequisites that were mastered years ago erode to the point where they no longer support the skills built on top of them. The practitioner continues operating with a capability model that no longer reflects reality.
The Researcher's Path framework describes the cumulative depth that produces genuine leverage — the practitioner whose understanding is not just broad but structurally sound, where each skill reinforces adjacent skills and the whole is more navigable than the parts. That structure does not emerge from ad hoc learning. It requires a system that tracks what exists, surfaces what is at risk, and prevents the silent erosion that undermines the foundation without ever producing a visible error.
The distinction between this build log and the Learning Infrastructure system document is the same distinction that exists between any build log and its corresponding system document. The system document describes what the system is and how it works. This document describes what it took to get there — what was tried and failed, what was abandoned, and what is still unresolved. Reading the system document alone produces an accurate picture of the current architecture. Reading this document produces an accurate picture of why the architecture is what it is.
Both are necessary. The architecture decisions that look obvious in retrospect — queue over calendar, binary over percentage, DAG over flat list — were not obvious before the failure that made them necessary. Documenting the failures is not retrospective self-criticism. It is the evidence that makes the decisions legible.
Two arcs, each forced by contact with sustained use
Six versions across two structural arcs. The first arc attempted to build a learning system as an extension of existing note-taking practice. The second arc rebuilt from the failures of the first with an explicit infrastructure framing. The diagram below shows the retention curve of a representative skill node across a sustained review cycle — the pattern that the scheduler is designed to maintain.
v0.1–v0.3 (arc one). The first arc treated learning infrastructure as augmented note-taking. Skills were tracked in a flat document. Review was calendar-scheduled. Capability was scored as a percentage. All three design decisions failed on the same axis: they required ongoing manual maintenance that was not sustainable under operational load. v0.3 was the last version in this arc. It was abandoned after the calendar collapse described in § 01.
v0.4 (transition). The transition version. The flat skill list was replaced with a DAG. Percentage scores were replaced with binary promoted/not. The calendar was replaced with a priority queue. These three changes happened simultaneously, which made it impossible to isolate which change was responsible for which improvement. A methodological error. v0.4 was more stable than anything in the first arc but the causal attribution is uncertain.
v0.5–v0.6 (arc two — current). The current arc. v0.5 added the decay model — the three-tier half-life estimates that drive review urgency scores. v0.6 added the promotion standard: explicit publish-standard evidence required for ledger entry. The arc is in progress. The open questions in § 08 are the active design problems in this arc. The system document for the current state is maintained separately at SYS-04.
From percentage estimates to binary evidence records
The capability ledger is the permanent record of what has been demonstrated to publish standard. Its schema has changed more than any other component across the six versions. The percentage model was the longest-running error — it persisted through v0.3 before the failure it produced became undeniable.
The failure of percentage scores was not imprecision — it was false precision that masked imprecision. A skill scored at 80% felt more informative than a binary "promoted." It was not. The 80% had no calibration basis. It reflected the practitioner's subjective confidence at the moment of assessment, which is known to be unreliable — practitioners systematically overestimate retention in the period immediately following acquisition and underestimate it after extended non-use. The percentage model produced ledger entries that were wrong in a way that looked rigorous.
The binary model resolves this by making the assessment externally anchored rather than self-assessed. A skill is promoted when publish-standard evidence exists — a published artifact, a implemented system, a documented decision record that demonstrates the skill under production conditions. This is the same standard used by the Education OS build log and referenced in the SYS-04 system document. The evidence anchor means the ledger contains only skills that have been tested, not skills that feel internalized.
The current open problem is demotion — detecting when a promoted skill has decayed below the INTERNALIZED threshold. Promotion has a clear criterion: publish-standard evidence. Demotion currently relies on the decay model to estimate when a review is required, but the decay model produces a recommendation, not a detection. A practitioner who should be reviewing a skill may not know it has decayed until they attempt to apply it. The gap between scheduled review and actual capability check is the primary reliability concern in the ledger at v0.6.
Why calendar scheduling is the wrong abstraction
Calendar scheduling fails for a structural reason that motivation and discipline cannot overcome. A calendar allocates time slots. When a slot is missed — because of external load, travel, deadlines — it becomes a gap. Gaps accumulate. The gap creates pressure: the practitioner now needs to catch up on missed reviews in addition to performing current ones. The accumulated pressure makes the system feel burdensome. The system is abandoned or reduced to sporadic use. Calendar-based learning systems produce this failure on a predictable schedule regardless of the practitioner's commitment level.
The queue abstraction is structurally different. A queue has no empty slots. It has a top item — the highest-urgency skill node as computed by the decay model. A missed session does not create a gap; it delays the top item, which moves up the urgency ranking and surfaces higher the next time the queue is consulted. The queue is stateless with respect to schedule — it reflects the current urgency ordering regardless of what was or was not reviewed previously. Missing a session does not make the system feel broken.
The practical consequence is that the queue-based scheduler survived the same overloaded weeks that collapsed the calendar-based system. When capacity was constrained, the queue surfaced the most urgent items and those alone were reviewed. The less urgent items waited. When capacity returned, the urgency ordering had updated to reflect the elapsed time, and the queue presented the correct items without any manual intervention to catch up.
The current limitation is that the queue does not account for prerequisite ordering at review time. It surfaces the highest-urgency items independently. If two high-urgency items are in a prerequisite relationship — skill B depends on A and both are urgent — the queue may surface B before A. Reviewing B without the prerequisite foundation solid is less effective than the urgency score alone would predict. This is documented in § 08 as an active open question.
Week-over-week deltas — the signal that survived contact with use
The early versions of the system used quarterly retrospectives as the primary feedback mechanism. Every three months, the ledger was reviewed: which skills had been promoted, which had been reviewed, which domains had grown. The retrospective produced a useful picture of the past quarter. It produced nothing actionable for the current week. The gap between the retrospective and the next one was too long for the feedback to influence day-to-day allocation decisions.
The current design measures week-over-week deltas: how many nodes moved from ACTIVE to INTERNALIZED, how many moved from INTERNALIZED to DECAYING, how many reviews were completed versus scheduled. The delta is small enough to be acted on. A week where no nodes were promoted surfaces immediately and prompts a question about whether the practice sessions were focused on active nodes or spent on consumption. A week where two nodes were promoted against a target of one surfaces the fact that pace is sustainable and capacity may be available to expand the active set.
The delta metric also makes the system self-correcting under load. When external demands increase and review sessions decrease, the decay model produces an urgency spike in the queue. The following week's delta shows more decaying nodes and fewer promotions. The signal is visible without requiring a quarterly retrospective to surface it. The feedback loop tightens the response time between reduced practice and visible system signal.
The limitation is that week-over-week delta conflates skill complexity with practice quality. A complex skill may require four weeks of active practice to promote. A week with no promotion is not necessarily a weak week — it may be a week of deep work on a node that is close to promotion. The current system does not distinguish these cases. A "days active on node" counter would provide the missing signal, but it has not been implemented. It is the next planned addition at v0.7.
Decisions, rationale, and current status
Seven architecture decisions that shaped the current system. Each Stable decision survived contact with sustained use. In review means the decision is correct in structure but requires calibration. Contested means no adequate solution has been found and the current approach is acknowledged as insufficient.
| Area | Decision | Status | Rationale |
|---|---|---|---|
| Scheduling | Queue over calendar | Stable | Calendar scheduling breaks the first overloaded week — empty slots create guilt, not output. A queue has no empty slots. It has only a next item, regardless of when capacity appears. |
| Decay model | Three-tier decay rates over continuous function | Stable | Continuous decay requires empirical calibration data that does not exist. Three tiers — procedural, structural, conceptual — are accurate enough for queue ordering without demanding precision the system cannot support. |
| Capability tracking | Binary promoted/not-promoted over percentage scores | Stable | Percentage scores produce false precision. '80% confident' has no calibration basis. Binary forces an honest assessment: can you produce publish-standard evidence or not? |
| Promotion standard | Publish-standard evidence required for ledger entry | Stable | Lower standards filled the ledger with 'familiar but untested' entries. The ledger looked healthy. The capability it represented was not. High standard means fewer entries — and entries that are true. |
| Graph structure | DAG over flat skill list | Stable | Flat lists hide blocking dependencies. The practitioner skips to interesting nodes, accumulates surface knowledge, and discovers blockers at application time — when the cost of the gap is highest. |
| Review triggers | Decay-clock over fixed interval | In review | Fixed intervals over-review stable skills and under-review recently acquired ones. Decay-clock is correct in theory. Not yet fully calibrated in practice — the right half-life parameters per tier remain uncertain. |
| Merge heuristic | Manual review over automatic merge | Contested | Automatic merge creates incorrect concept links at the abstraction boundaries. Manual merge creates a backlog that grows faster than it can be cleared. No adequate solution found. |
What is not resolved
These questions are not speculative. Each one is an active constraint on the system's reliability at v0.6 — a decision that has been deferred because the correct answer requires data or design work that does not yet exist.
What are the correct decay half-life parameters for each skill tier?
ActiveThe three-tier decay model (procedural / structural / conceptual) is correct in structure. The half-life estimates assigned to each tier are derived from intuition, not measurement. A procedural skill — syntax, tool operation — is assigned a shorter half-life than a conceptual skill — architectural reasoning, causal models. The relative ordering is defensible. The absolute values are not validated. A miscalibrated half-life means the scheduler surfaces reviews too early or too late. The miscalibration is silent — the system produces a queue, and there is no external signal that the queue ordering is wrong.
How do you detect skill drift without an objective external test?
ActiveThe promotion standard requires publish-standard evidence. There is no equivalent standard for detecting regression — a skill that has decayed past the INTERNALIZED threshold. The decay clock estimates this, but estimation is not detection. A practitioner who believes a skill is retained but cannot produce evidence of retention is not reliably distinguishable from one who correctly assesses retention without being tested. The system has no mechanism for surfacing this difference.
When should the curriculum graph be restructured rather than extended?
ActiveThe graph grows by adding nodes and edges. Over time, the accumulated structure may be wrong at a high level — the decomposition that made sense early is not the decomposition that serves the practitioner's current direction. Restructuring the graph requires reclassifying existing nodes, re-evaluating prerequisites, and potentially demoting promoted skills whose context has changed. There is no criterion for when restructuring becomes more valuable than extension. The cost of a wrong graph structure is invisible — it manifests as mis-prioritized reviews and blocked next nodes, not as explicit errors.
Is the merge heuristic problem solvable without a domain taxonomy?
ContestedThe current merge approach — manual review — is correct in that it produces the right decision. It is wrong in that it cannot keep pace with input rate. The alternative — automatic merge using embedding similarity — produces plausible but semantically incorrect merges at concept boundaries. A domain taxonomy that could adjudicate borderline cases would resolve this, but building a taxonomy requires exactly the kind of stable, settled understanding of the domain that a learning system is designed to develop. The dependency is circular.
How does the system behave when two high-priority review items conflict with each other as prerequisites?
ContestedThe scheduler produces a queue. The queue is ordered by urgency score. In the current implementation, two items at the top of the queue are assumed to be independent — the practitioner can work through them sequentially. If the items are in a prerequisite relationship, sequential processing may not be valid: reviewing B before A may be less effective than reviewing A first. The scheduler has no awareness of prerequisite structure at review time. It uses the DAG for initial prioritization but does not re-evaluate prerequisites during review scheduling.
Current status — honest accounting
The system is in daily use. The queue-based scheduler has survived six months of sustained use including multiple high-pressure periods that collapsed the calendar-based predecessor. The binary ledger contains fewer entries than the percentage ledger it replaced, and every entry is accurate. The DAG surfaces blocking dependencies before they become friction at application time. These are the components that work.
The system is not finished. The decay model's half-life parameters are unvalidated estimates. The merge heuristic is acknowledged as insufficient and has no adequate solution. The feedback loop does not distinguish deep work on complex nodes from shallow or absent practice. The prerequisite ordering at review time is not implemented. The graph restructuring criterion does not exist.
Iteration 002 is the first iteration that has been explicitly documented in a build log rather than tracked informally. The documentation discipline is itself an output of the system it documents — the publish-standard evidence requirement for the capability ledger creates a pressure toward written artifacts that this build log satisfies. The system and its documentation are in a compounding relationship. That is what the system is supposed to produce.
BLD/LRN · ITERATION 002 · IN DEVELOPMENT
Continue Reading