A growth problem reframed as an infrastructure problem
The default approach to technical skill development is personal: set intentions, maintain discipline, feel the urgency. It fails not because the practitioner lacks commitment but because the problem is architectural. Skills decay without use. Prerequisites block progress invisibly. Effort distributes across the path of least resistance rather than highest leverage.
Learning Infrastructure reframes this. It treats the skill set as a graph with structure, treats capability retention as a decay problem with measurable parameters, and treats practice allocation as a scheduling problem with a computable solution. The output is not motivation — it is a queue. The practitioner executes the queue.
This system operates alongside the Education OS, which provides the structured curriculum input. The Education OS is top-down: it processes deliberate prerequisite sequences. The Learning Infrastructure is the runtime beneath it — the layer that tracks, schedules, and records what the OS produces.
The distinction matters. Curriculum design and runtime infrastructure are separate problems. Conflating them produces systems that are good at planning and bad at compounding.
Skill lifecycle as a state machine
Every skill node in the system passes through a defined set of states. The architecture is built around this lifecycle: intake routes new nodes into the graph, scheduling drives nodes toward Internalized, and decay monitoring prevents silent regression once they arrive.
The architecture has four layers that map directly to these state transitions: Structure (the curriculum graph that defines what nodes exist and their dependencies), Scheduling (the decay model and practice scheduler that compute when to act), Execution (the review queue, the daily surface), and Record (the capability ledger that tracks what has been earned and retained).
The layered separation matters operationally. Changing the curriculum graph — adding skills, adjusting prerequisites — does not require touching the scheduler. Changing the decay model does not require modifying the ledger. Each layer has one job.
Structure before scheduling
The curriculum graph is a directed acyclic graph of skill nodes and prerequisite edges. A node is a discrete, testable capability. An edge from A to B means B cannot be meaningfully practiced without A being at Internalized or Reinforced state.
The graph serves a specific purpose that willpower-based systems miss: it makes blocked progress visible. When a practitioner feels stuck, the default attribution is effort. The graph makes the correct attribution legible — the skill is blocked, not the practitioner. The next action is to resolve the blocking node, not to apply more force to the blocked one.
The graph is the structural input for the Education OS, which handles curriculum design — deciding which skills belong, how prerequisites are structured, which paths through the graph match operational goals. Learning Infrastructure does not design the graph; it executes against it.
The graph also surfaces the concept of a next viable node — the highest-leverage skill that has no unresolved dependencies. This is the scheduler's input. Without the graph, the scheduler has no principled basis for queue ordering.
A diagnostic: cycles in the curriculum graph almost always indicate a decomposition error. If A depends on B and B depends on A, the actual structure is that both depend on a third node C that has not yet been identified and isolated. Finding C is more valuable than attempting to schedule around the cycle.
Practice allocation as a computable problem
Capabilities decay. This is not a motivational observation — it is a measurable property of how skills are retained. The decay model assigns a half-life parameter to each skill node based on its type: procedural skills (syntax, tool operation) decay faster than structural skills (architectural patterns, mental models), which decay faster than conceptual skills (theoretical foundations, causal reasoning).
The decay model does not require high precision. A coarse approximation — three decay rate tiers — is sufficient to produce a scheduler that outperforms intuition-based practice allocation by large margins. The failure mode in personal learning systems is almost never "decay model not precise enough." It is "no decay model at all."
The practice scheduler takes the graph's next-viable-node outputs and the decay model's urgency scores and produces an ordered queue. The queue has two zones: urgent (nodes whose urgency score has crossed a threshold, indicating risk of state regression from Internalized to Decaying) and developmental (nodes in Active state that are progressing toward Internalized).
The critical design decision: the scheduler outputs a queue, not a calendar. A calendar implies slots that can be empty. A queue implies that the next practice session always has a defined top item. Calendar-based systems fail because they distribute work to available time. Queue-based systems succeed because they define the next action regardless of when capacity appears.
This architecture connects to the Technical Readiness framework, which uses the same decay reasoning to assess whether a practitioner's current skill state matches the demands of a given technical environment. The scheduler prevents the regression that readiness assessment measures.
The permanent record of what has been earned
The capability ledger is a versioned record of skill nodes that have reached Internalized state. Each entry includes the node, the date of promotion, the evidence used to justify promotion, and the current state (Internalized or Reinforced or Decaying).
The promotion standard is strict by design: a skill node is promoted to Internalized only when evidence of publish-standard application exists. This is the same standard used in the AI Second Brain system, where the publishing surface is the primary evidence source for ledger promotions. You can produce it in public, or you cannot produce it.
The strictness is not perfectionism — it is a calibration mechanism. Without a hard promotion standard, the ledger fills with nodes that have been encountered and felt familiar but have not been tested under production conditions. A ledger full of such nodes is worse than an empty ledger because it creates false confidence in the practitioner's readiness assessment.
The ledger serves three operational functions. First, it is the input to the decay model — only ledger entries have decay clocks running. Second, it is the input to any external capability representation — résumés, proposals, positioning documents can only truthfully reference ledger entries. Third, it is the compounding record: the ledger grows monotonically, and its entries form the foundation for the capability depth that the Researcher's Path framework describes as the prerequisite for genuine leverage.
The ledger version number tracks major structural changes to how capabilities are categorized. A version increment means prior entries have been re-evaluated against an updated taxonomy, not that prior capability was lost.
Component reference — SYS-04 v0.6
Current operational state of all system components. Intake layer (LRN-INGEST) remains in design; present workaround is manual routing decisions at intake. All scheduling and record components are active.
| Code | Name | Layer | Status | Description |
|---|---|---|---|---|
| LRN-GRAPH | Curriculum Graph | Structure | Active | DAG of skill prerequisites. Surfaces next viable nodes when blockers resolve. Prevents forward progress on disconnected skills. |
| LRN-DECAY | Decay Model | Scheduling | Active | Estimates capability half-life per skill node. Assigns urgency score that drives review queue ordering. |
| LRN-SCHED | Practice Scheduler | Scheduling | Active | Generates ordered practice queue from decay estimates and graph position. Output is a queue, not a calendar. |
| LRN-LEDGER | Capability Ledger | Record | Active | Versioned record of internalized skills. Promotion from Active to Internalized requires publish-standard evidence. |
| LRN-REVIEW | Review Queue | Execution | Active | Daily review surface driven by scheduler output. Not a manually maintained calendar — urgency is computed, not felt. |
| LRN-INGEST | Input Processor | Intake | In Design | Routes new material to curriculum graph (structured prerequisites) or Knowledge Forge (opportunistic discovery) depending on source type. |
v0.6 status. Core scheduling loop (LRN-DECAY + LRN-SCHED + LRN-REVIEW) is stable and in daily use. Curriculum graph (LRN-GRAPH) covers current AI systems domain; expansion to adjacent infrastructure domains is scheduled for next version. Input processor (LRN-INGEST) is the primary open design problem — the routing decision between curriculum intake and Knowledge Forge intake is currently manual and inconsistent. A formal routing heuristic is the primary v0.7 design goal.
Known gap. The decay model currently uses three fixed tiers. Empirical calibration against actual review outcomes is planned but has not been prioritized. The current model is accurate enough for queue ordering; imprecision only matters at the boundary cases where urgency scores are close. The operational risk is low.