loom

loom

A personal user-model graph for Claude Code. Builds a map of what you know so explanations from the LLM land cleanly in your specific mind.

Why this exists

I wanted to actually read research papers. Every explanation I found was at one of two extremes:

• Too deep — assumed I already had the field's background
• Too generic — the same surface intro for everyone, with no anchors to what I actually knew

What I wanted: explanations that already knew what I already knew, so they could meet me where I am, and build outward from there.

Loom is the layer that makes that possible.

The principle

Loom models you, not the world.

• Learning is just connecting dots you have to dots you don't.
• An explanation lands when it's anchored to something you already grok.
• Not the world. Just you.

The LLM already contains the world's knowledge — definitions, formulas, taxonomies. What it lacks is you: your vocabulary, the analogies that click, the concepts you understand at depth, your mental frames, what's confused you before. Loom maintains that model.

Every explanation is two steps:

1. Query the user model — "what does this person know that's relevant?"
2. Generate the explanation — anchor new ideas to known ones, use their vocabulary, skip what they've mastered, avoid analogies that confused them before.

What it looks like

After a few sessions, /me shows something like:

**Persona**
Prefers code-first explanations. Reasons through the request lifecycle.
Recent sessions on graph databases and ML systems.

**Top mastery**
| Concept                | Depth   | Mastery |
|------------------------|---------|---------|
| Matrix multiplication  | TEACH   | 0.95    |
| Softmax                | EXPLAIN | 0.85    |
| Vector indexing        | TEACH   | 0.92    |
| Knowledge graphs       | EXPLAIN | 0.70    |
| Cypher                 | EXPLAIN | 0.65    |

**Preferences**
- explanation_style = code-first (conf 0.90)
- depth_preference  = scaffolded (conf 0.85)

Anything wrong? Use /correct to fix.

Now ask /loom-learn attention:

A generic LLM gives you:

Attention is a mechanism that lets a model focus on relevant parts of the input when producing each output. It uses queries (Q), keys (K), and values (V): for each output position, compute a weighted sum of values, where the weights come from how well the query matches each key. The standard formula is Attention(Q,K,V) = softmax(QKᵀ / √dₖ)V. Multi-head attention generalizes this by running multiple attention operations in parallel and concatenating...

Loom gives you:

Since you already know matrix multiplication (mastery 0.95, TEACH) and softmax (mastery 0.85, EXPLAIN), and you prefer code-first:

Attention is basically:

for each output position:
    weights = softmax(Q @ K.T / sqrt(d))   # how aligned each query is with each key
    output  = weights @ V                  # weighted sum of values

Three matrix multiplies and a softmax in the middle. That's it.

The / sqrt(d) divisor is the only trick — it stops the softmax from saturating when d gets large. Same shape of fix as the batchnorm-before-activations frame you already use.

Skipping positional encoding — you already TEACH that (mastery 0.94).

Save this to your model? (save / save+continue / keep going)

Same topic. Different explanation. The second one assumes (correctly) you already grok matmul, skips the math derivation, leans on a frame you already use, and offers to capture what just landed.

How it works

Three layers.

MCP tools

A local TypeScript MCP server backed by Neo4j exposes 10 tools to Claude Code:

• Write: update_user_model, correct_user_model
• Convenience reads: query_user_model, get_user_summary, audit_graph
• Exploration primitives: search_by_topic, get_node, get_neighbors, get_signals
• Diagnostic: ping

Atom skills

Single-purpose, independently invokable:

Skill	What it does
/me	Show the user-model snapshot (the trust loop)
/learn	Extract user-state signals from recent chat → write
/correct	Fix what the model has wrong (natural-language → structured action)
/explain	Personalized explanation of a topic (read-only)
/onboard	Adaptive interview to seed the graph (resumable)
/review	Surface and reinforce decaying knowledge via explain-back quiz
/audit	Graph health check — orphans, stale-but-high, duplicates, etc.

Meta-skills

Orchestrate atoms into guided sessions: