Last post was about mytraces: a travel-planning tool built on a curated ontology and an LLM, doing different jobs that each are more useful because the other exists. A few people wrote in to ask whether that shape was unique to trip planning or something we keep reaching for. Honest answer: we keep reaching for it. The first time we used it was actually before mytraces — for an education tool that's been live for a while. A third instance just landed, for programming. Three is enough that the pattern is worth writing down on its own terms.
The shape, in one paragraph
A small graph of concepts in some domain, with typed relationships between them (prereq, extends, co-occurs, or whatever the domain's edges turn out to be), and curated references hanging off each node. A user has state per concept: not-yet, learning, mastered, stuck. Regimes project the same ontology onto different audiences — same data, different filters and weights. The whole thing is small enough to author by hand and read on a Sunday afternoon. The system gets smarter as the curator does, not as the corpus grows.
We've now built that shape three times.
One: pre-algebra
The first instance, and the one that's been live for a while, ships under the StoneCamp education family as SC PreAlgebra — a small parent-shaped tool for K-12 math. Concepts are the ~80 building-blocks of pre-algebra (variables-and-expressions, fractions-on-a-number-line, ratios-and-rates); the edges are prereq (you need this first), extends (this deepens the previous), co-occurs (these tend to cluster). References are 270+ hand-picked Khan Academy / OpenStax / Math Antics / Math is Fun links. State is what you'd expect.
The shape held up. A parent who couldn't have read a curriculum standard could read the map. A tutor running three students didn't have to remember which prereqs were sticking; the graph showed it. PreAlgebra didn't need an LLM to do its core job — the ontology alone was enough — and that turns out to be the cleanest test of whether the pattern is really earning its keep. If the graph is doing the work, the model is a nice add-on. If you're leaning on the model to compensate for a thin graph, you'd notice. The first instance built our confidence that the pattern was load-bearing on its own.
Two: travel (mytraces)
Mytraces took the same shape into a domain where free-form natural language is the user's natural input. Concepts are travel moods and place-types (contemplative, alpine, family-with-kids); relationships are weighted modulators (contemplative amplifies forest-bathing); curated places are the leaves; user state is preference drift. Regimes are season, group, transit mode, repeat-visitor. The new piece in this round was the model: the ontology parses a typed sentence into structured signals, runs the graph, and the model composes the reasoned candidates back into prose. Two pillars, doing different jobs — last week's post covered this in detail. Internal dogfood for now.
Three: programming
The new one ships as SC Programming — same family as PreAlgebra, very different domain. The map covers ~80 concepts across the usual ten groups (basics, collections, search/sort, data structures, algorithms, OOP, software practice, networking, AI hands-on, AI engineering); the edges are the same three types; the references are field-standard (Python docs, MDN, cppreference, Anthropic prompting guides, USACO Guide, AtCoder problem links).
What's different is the audience axis. Pre-algebra has one audience — a kid working through Common Core. Programming has many: first-timer, working developer, AP Computer Science A student, competitive programmer, AI engineer, CS depth student. The same concept (say, recursion or dynamic programming) shows up in most of those, but with different surrounding context, different recommended anchor language, different "what's next." So the regime idea grew a bit: instead of one filter token per regime, every concept now has a level (intro / core / advanced) and a small set of audience tags (cp, apcs-tw, industry, ai, web). A regime is a six-line config that picks groups, caps level, includes/excludes audiences. Six tracks come out of the same ~80 concepts, no duplication.
What's shared, what isn't
PreAlgebra and Programming sit under the same umbrella we publish education tools through (StoneCamp; grove and lithica are quietly cooking next to them). They share login, design language, and — newly — a small internal library that holds the d3 concept-graph, the three-column layout, and the LHS tree. Each app brings its own ontology, its own server, its own deploy. The shared piece is just the chrome.
Mytraces stays separate; it's a different stack and a different brand. The pattern travels, the implementation doesn't have to. That's the right scale of sharing for a small workshop: enough that we don't rebuild d3 graphs three times, not so much that any one app holds the others hostage.
Why this keeps winning
Three reasons. First: the curator's understanding is the leverage. A handful of well-chosen concepts and well-shaped edges does more than a million crawled facts. The bar to add a node is "the curator can articulate why it earns its place," and that bar is high enough to keep the graph small.
Second: the user can see the reasoning. The map shows you what's behind a "next-step" suggestion, what's behind a place recommendation, what prereqs you need before that ratios chapter pays off. The model alone can't do that without sounding plausibly made up. The graph forces transparency.
Third: state persists. Concept-state is the same data shape across all three apps — per-(user, concept) with an append-only history. We can timeline it, propagate it, diff a classroom against an assignment. The same primitive handles "which fractions topics has my child mastered" and "which DP patterns is this APCS student stuck on." The domain changes; the bookkeeping doesn't.
What we're deliberately leaving out
The programming sibling is intentionally pre-beta. Three things we know we want, that we have not built:
- An R3-style reasoner over the graph. Programming could absolutely have an "ask about a concept" / "explain this prereq path" mode driven by an LLM grounded in the ontology — the same two-pillar shape mytraces uses. Not before the graph itself has been used in anger.
- An ingest pipeline. Authoring 200 AtCoder problems by hand is slow; we know how to scrape + manifest + review. We're holding off until the manual pace is the actual bottleneck. Until then, manual is more accurate.
- A heavy classroom layer. Tutors get a small roster + per-assignment progress view; that's it. Anything bigger means we're competing with grade-book tools, which is not the work.
Where it lands
Programming will go to one tutor first — a colleague who teaches APCS Taiwan students — for real classroom use, not a demo. PreAlgebra keeps doing what it's been doing. Mytraces stays internal until a planned trip survives the system. The pattern is the part we're confident about; the surface area of any one app is deliberately narrow, and stays narrow until the curator side proves out.
Three concept graphs, one architecture. We'll write again when one of them has a story worth telling on its own. Small steps; no launches; no big reveals — just notes from the workshop floor.
← All journal posts