Most technical learning plans are polite fictions: linear curricula that bear no resemblance to how capability actually accumulates.
The default model of “learning AI” looks something like this: assemble a list of courses, tutorials, papers, and projects; arrange them from beginner to advanced; work through them top to bottom. The list feels like a plan. It is not a system. It is a queue. When the queue is finished, it leaves behind something that looks suspiciously like the starting point: a vague sense of familiarity, a folder of half-finished notebooks, and no reliable way to answer a simple question — what, precisely, can you do now that you could not do before?
This build log documents the third serious attempt to replace that fiction with an operating system. The goal is not a prettier curriculum. The goal is a system that can answer three questions at any time with enough precision to make real decisions:
- What is the current shape of capability?
- What should be learned next, and why?
- What is decaying, and when does it need practice?
The constraints: the system must survive tool churn, must be measurable, and must compound over years rather than weeks. It must be opinionated enough to be useful and flexible enough to survive contact with reality. And, critically, it must be used while real work is happening — not in a sandbox where nothing is at stake.
Effort accrues. Capability does not — unless it is wired into a system.
The failure pattern this build log is responding to is simple: long periods of high-effort study that leave behind surprisingly little durable capability. The calendar shows weeks of learning. The output shows familiar patterns — re-reading the same papers, re-deriving the same intuitions, rediscovering the same implementation gotchas that were already encountered six months ago.
From the Researcher’s Path perspective, this is the Learner stage spinning its wheels. Information is being consumed, but the transition to Builder and Operator is not happening reliably. The missing piece is not more input. It is infrastructure: nothing is keeping track of what has actually been internalized, what is decaying, and what work is most leverage-bearing to do next.
Three structural issues appear across every previous attempt:
Flat curricula. Lists of resources treat learning as linear. Real capability-building is graph-shaped: some skills are prerequisites for many others, some can be learned in parallel, and some are dead ends. A flat list cannot express this. It also cannot show cycles — the subtle cases where “skill A requires skill B” and “skill B requires skill A,” which usually means the abstraction is wrong.
No ledger. Learning systems that do not write to a ledger are unmeasurable. Without a structured record of which skills exist, what their current level is, and what evidence backs that level, there is no way to query “what am I actually capable of?” or “what changed in the last six months?” The system can only answer feelings, not questions.
Practice scheduling by guilt. In the absence of a spacing system, practice happens when guilt exceeds distraction. Something “feels rusty,” a hard problem exposes a forgotten concept, or a calendar reminder from an old course resurfaces. The intervals are arbitrary. Decay wins.
The AI Education OS is an attempt to replace all three with a single coherent architecture: curriculum as a graph, knowledge as a ledger, practice as an explicit loop. It handles structured prerequisite learning — material deliberately sequenced. The complementary pipeline for information encountered in the wild is the Knowledge Forge. The two systems are distinct but feed the same capability record: one top-down from curriculum, one bottom-up from curiosity.
Two failed attempts before the current architecture.
This is iteration 003. The first two attempts are worth recording because they explain several strong constraints that now feel non-negotiable.
Iteration 001 — Linear tracks in a notes app. The first attempt was a set of topic tracks (ML fundamentals, LLMs, tooling, evaluation, deployment), each with a list of resources and checkboxes. Progress was binary: done or not. There was no representation of skill, no prerequisite structure, and no record of decay. It felt organized and produced almost no durable change. Once a track was checked off, it disappeared from view until something broke badly enough to force a revisit.
Iteration 002 — Skill tags inside notes. The second attempt introduced skills, but embedded them as tags and headings inside regular notes. This allowed some aggregation (e.g., “show me all notes tagged evals”), but the skill model and the note model were fused. Graph queries became brittle, and there was still no notion of level, evidence, or decay. It was a more sophisticated filing cabinet, not an operating system.
Iteration 003 — Dedicated graph + ledger + loop. The current iteration separates three concerns:
- A curriculum graph — a DAG of skills and their prerequisites.
- A capability ledger — structured records for each skill, with level, evidence, and timestamps.
- A spaced practice loop — a scheduler that issues practice prompts based on decay, not guilt.
Each has its own data model and can, in principle, be implemented with different tools over time. The build log from this point forward describes how each is being designed and wired together, and which decisions have already survived contact with reality.
Replacing flat lesson lists with directed graphs of skill prerequisites.
The curriculum graph is the backbone of the system. It answers a specific question: given the skills that exist in this domain, what depends on what? It is not a content graph. It does not know about courses or articles. It only knows about capabilities — things a practitioner can demonstrably do.
The current model:
- Nodes are skills at operator granularity: “design an eval harness for an LLM-backed API” rather than “evaluation.”
- Edges are prerequisite relationships: to acquire skill B, you must already possess skill A at a certain level.
- The graph is constrained to be a DAG. Cycles are a sign the abstraction is wrong. When a cycle appears, the skills are re-factored until the cycle breaks.
The first non-obvious design decision was granularity. Too coarse — “deploy LLM systems” — and the graph hides the real dependency structure. Too fine — every micro-operation as a skill — and the graph becomes unmanageable. The working heuristic: a skill should be something that can be brought from zero to demonstrable in a focused one-to-two hour session. Anything bigger gets split. Anything smaller gets merged.
The second decision was to treat content as an annotation on the graph, not part of it. Courses, papers, and tutorials are attached to skills as ways to move up a level, not as fundamental units. This prevents the graph from being distorted by the structure of individual resources. If a course jumps between three unrelated skills, the graph models those skills separately. The course is just one possible path through them.
The graph representation itself is intentionally tool-agnostic: adjacency lists and node attributes live in a structured store, with downstream views in whatever interface is most useful — visual map, table, or API. This mirrors the design principle in Technical Readiness: keep the architecture clean even when the surface shifts.
A versioned record of what has been internalized vs. surface-read.
The ledger is where the system becomes measurable. Each skill in the graph has a corresponding ledger entry with, at minimum:
- A level (Unknown → Familiar → Operator → Architect).
- Evidence (links to artifacts: code, writeups, evaluations, incidents resolved).
- Timestamps (first acquired, last refreshed, last used).
- A confidence score — subjective, but grounded in the evidence available.
The level scale borrows directly from the Researcher’s Path and compresses it into a per-skill axis:
- Unknown — the skill exists in the graph, but there is no meaningful familiarity.
- Familiar — concepts understood in theory; unable to operate reliably under constraints.
- Operator — can execute the skill in real contexts, under time pressure, with acceptable failure rates.
- Architect — can design systems around the skill, teach it, and debug it in edge conditions.
The evidence requirement is non-negotiable. A skill cannot be marked as Operator without at least one artifact that would convince a skeptical third party: a deployed feature, a resolved incident, a build log entry, a writeup that passes the would-publish bar. This slows apparent progress and speeds real progress by making inflation harder.
Practically, the ledger is stored as structured records, not fused into notes. v002 attempted to store skill status inside notes as frontmatter and tags. The result: no reliable way to query “show me all skills at risk of decay” or “what changed between Q1 and Q3.” v003 moves the ledger into its own table with an explicit schema and treats notes as evidence attachments.
The ledger is what turns “I’ve been learning a lot lately” into a queryable object. It also introduces a hard constraint: if a learning cycle does not write to the ledger, it did not happen as far as the system is concerned. This is intentionally unforgiving. The same logic applies in the Knowledge Forge: publication is the primary evidence of internalization. The ledger makes that standard explicit at the skill level — the Forge handles information encountered in the wild, the Education OS handles structured prerequisite sequences, and both write evidence to the same capability record.
Practice scheduling tied to capability decay, not arbitrary intervals.
Traditional spaced repetition systems operate on items in isolation: flashcards with review intervals determined by an algorithm that models memory decay in the abstract. This build is solving a different problem: scheduling sessions that exercise clusters of related skills at the right time, based on how those specific skills are decaying in practice.
The loop:
- The scheduler queries the ledger for skills whose last-use and last-review timestamps suggest they are entering a decay window, weighted by current level.
- It groups compatible skills (e.g., “RAG retrieval debugging” + “eval harness design”) into session candidates.
- It proposes one to two sessions for the week, with concrete exercises tied to real artifacts (write an eval, debug a failure, implement a small pipeline).
- Completed sessions write back to the ledger with updated timestamps, adjusted confidence, and links to new artifacts.
v003 does not yet implement per-skill decay curves. Instead, skills are bucketed into rough categories:
- Muscle-memory skills (implementation, debugging) — decay quickly without use.
- Conceptual frameworks — decay slowly but warp without occasional re-exposure.
- Procedural rituals (eval workflows, incident runbooks) — decay invisibly until an incident reveals the rust.
Buckets have default intervals. The long-term plan is to learn per-skill curves from actual behavior: if a skill repeatedly fails review at a given interval, the interval is too long. The system is intentionally conservative — it would rather schedule slightly too much practice than allow slow decay to go undetected.
The practice loop is not a review system. It is a decay detection and repair system. The goal is not to refresh memory. It is to verify that the capability is still operational and to rebuild it when it is not.
Three core stores. One scheduler. Multiple interchangeable surfaces.
At iteration 003, the architecture is deliberately boring:
- A graph store for skills and prerequisites (curriculum graph).
- A relational store for ledger entries.
- A scheduler service that reads from the ledger and writes back session outcomes.
- A set of adapters that sync captures and notes from active tools into the core — notes app, task manager, calendar.
The critical design choice is what is not coupled. The learning OS does not care where notes live, as long as they can be linked back to skills as evidence. It does not care which task system the practice sessions surface in, as long as completion events are written back. This is the same separation principle used in the Learning Infrastructure system: infrastructure first, interfaces second.
The weakest point of the current architecture is the adapter layer. Tool APIs are inconsistent. Some data flows are still manual. The log is being written at this stage explicitly so that the pressure to make adapters less brittle comes from usage, not from architectural aesthetics.
What has survived contact with reality so far.
Build logs exist to record decisions, the context they were made in, and whether they turned out to be correct. This is the current decision table for BLD/EDU.
| Area | Decision | Status | Rationale |
|---|---|---|---|
| Curriculum structure | Model curriculum as a directed acyclic graph (DAG) of skills rather than linear course tracks. | Kept | Prerequisite relationships are not linear. DAG makes holes and cycles visible; supports multiple entry paths. |
| Skill granularity | Capture skills at operator-action granularity — things demonstrable in a session — not broad topic labels. | Kept (calibrating) | Too coarse hides gaps; too fine explodes graph size. Heuristic: a skill should be demonstrable in under two hours. |
| Ledger location | Maintain the capability ledger as a first-class data store, not embedded in prose notes. | Replaced v002 → v003 | Ledger-in-notes was unqueryable and unmeasurable. Dedicated store enables progress queries and decay scheduling. |
| Evidence model | Require explicit evidence (artifact, exercise, or production usage) before marking a skill as internalized. | Kept | Subjective self-report inflated capability. Evidence requirement slowed apparent progress and increased real trust in the ledger. |
| Spacing algorithm | Tie practice scheduling to capability decay curves per skill, not fixed global intervals. | In design | Different skills decay at different rates. Current implementation uses rough buckets; custom curves are planned. |
| Tooling stack | Separate graph, ledger, and scheduler as independent services integrated via APIs — not one monolithic app. | In progress | Keeps the conceptual model clean and allows swapping frontends without rebuilding core data structures. |
Legend: Kept — decision stands as load-bearing. In design — being exercised in low-stakes contexts. Replaced — recorded to prevent regressions.
The parts that are not working yet.
A build log that only records solved problems is a retrospective, not a log. Current open questions for BLD/EDU:
- Decay modeling. How much modeling effort is justified before real usage data exists? Is it better to overfit an explicit curve or run with simple buckets until the ledger has enough history to learn from?
- Skill boundaries. The current granularity heuristic is serviceable but fuzzy. Where should skills be split or merged to better match the stage transitions without over-complicating the graph?
- Emotional ergonomics. How should the system surface decay and gaps without becoming a guilt engine? What is the right level of friction to encourage practice without overwhelming the calendar?
- Integration with real work. How tightly should the OS couple to live projects? Should every project create expected skill changes in the ledger, or should project-level learning remain an annotation rather than a hard dependency?
- Multi-person extension. The current design is personal. What would need to change to make the same OS useful for a small team without turning into a learning management system — which this explicitly is not?
These questions are intentionally unanswered in v003. The system is being run in a constrained personal context until enough friction accumulates to justify changing the architecture. Iteration four will either validate the current design or document the reversals.
A living system, not a course.
The AI Education Operating System is not a curriculum product. It is the infrastructure beneath whatever curriculum happens to be in use at the moment. Courses, books, papers, and projects will change. The operating system should not have to. If it does, the abstraction was wrong.
The long-term bet is that learning treated as infrastructure behaves more like leverage than like effort. Time invested into the curriculum graph, the capability ledger, and the spacing loop pays out on every future decision about what to learn next, how to practice, and what to say no to. The absence of this infrastructure shows up as repetition: the same concepts relearned, the same mistakes repeated, the same blind spots rediscovered under new names.
This log remains an in-progress record. Iteration 003 is the first version that feels like an operating system rather than a spreadsheet. It is not yet stable enough to be recommended as a template. The purpose of publishing at this stage is to create an artifact that future iterations can contradict specifically, rather than vaguely.
The next entries will document how the OS behaves when applied to a concrete program of study and how it integrates with the broader learning infrastructure system. Until then, the correct status is the one already in the header: in development.