Don’t forget to learn: a system for learning with AI without starting from scratch

What happens when technology moves so fast you can’t keep pace? Articles about AI echo across every forum and social feed. Speed. Productivity. “Our company doesn’t write code anymore.” But nobody talks about the part that matters: what about learning? Learning with AI sounds like the natural way out — if it writes code for you, it should be able to teach you too — yet almost no one explains how to do it in a sustained way.

Tech has always been synonymous with constant updating. New frameworks, libraries, technologies, and so on. But artificial intelligence has left a large share of technical professionals lost, unsure of what to even study. Not even the mentors have it figured out.

On top of that, keeping up discipline and consistency is hard. Client projects still eat up most of the day. And when you do find that gap for studying, the context switch keeps you from making the most of short sessions (20–30 minutes).

Learning with AI: from generic chat to a mentor that actually remembers you

Using any of the generic models as a “mentor in your pocket” is an attractive claim. The promise is seductive: a single prompt away, you have something that answers questions at any hour, explains a concept five different ways, and never gets tired of being asked the same thing twice. And for resolving a one-off doubt, it works.

The problem shows up when what you want isn’t to settle a stray question, but to learn in a sustained way. The chat remembers nothing about you.

Not what level to pitch itself at, not what you did the last time you studied, not what tripped you up last week. Every conversation starts from a blank page. That turns learning with AI into a loop of re-supplying context: each session begins by explaining who you are, what you know, and what you want, and by the time it’s done calibrating, half your time is already gone. A good human mentor doesn’t work that way. They know you, they remember where you left off, and they tune the next session from there.

Then I had an idea. What if, instead of using AI as a plain chat I have to feed context to every time, I built a learning system? The underlying intuition was simple: AI performs much better when it stops guessing the context and reads it from a fixed place. If I could store my learning context outside the chat, I’d stop starting from zero every day.

That’s how the learning skills were born: pieces the AI loads on its own, depending on what I ask, backing the context with files that don’t vanish when you close the window.

The memory isn’t in the chat, it’s in files

I laid out the underlying problem above: the chat remembers nothing about you. So the first decision was the most important one in the whole system: the memory doesn’t live inside the AI, it lives in a folder of text files that I control.

Everything hangs off ~/.claude/learning/: a profile.md with who I am and what I want to improve, a backlog.md with what I want to learn, the active and archived lessons, the logs from each session, and the reports. Plain Markdown. No database, no server, no application.

I considered setting up a small database or an app with its own interface, but I ruled it out for three reasons:

1. The text files are read and written by the AI itself natively, with no intermediate layer to maintain.
2. I can open them, edit them by hand, and version them with git like any other code.
3. The knowledge about my learning is mine — and this was the deciding reason — and I want to be able to read it without asking any tool for permission.

The cost of this decision is that there’s no pretty dashboard with charts: if I want to see my progress, I see it in plain text. For me, it’s a trade-off that pays off.

The diagram below is, literally, the map of that folder: each gray box is a .md file, and each arrow, a skill that reads or writes it.

Six small skills, each with a single job

Looking at the diagram, you can see the pattern before reading a single explanation: there’s no one “learning” skill that does everything, but several small ones, and each only touches the files it’s responsible for. That was a deliberate decision. A skill that does everything is a skill that does nothing well: it’s long, unpredictable, and when something breaks, you don’t know where to look. Split it up, and each piece is short and easy to fix.

And there’s one detail I especially like: I never “run a skill.” I don’t type commands. I tell the AI “I want to learn” and the session starts; I tell it “I’m done for today” and it closes. Each skill is triggered by what I ask in natural language, so the system disappears, and only the conversation is left.

What the diagram doesn’t tell you is why each one exists, and that’s where the interesting decisions are:

• init-learning creates the profile. It’s the only one that writes who I am, what I want to improve, and — the piece of data used most afterward — how much time I have per session.
• new-learning consults that profile and fills the backlog. It solves the “I don’t know what to study”: it crosses my gaps with what was left shaky before and proposes ideas already broken into pieces.
• learn is the center of gravity. It consults the backlog, the current state (current.md), and the intelligence layer (insights.md) before starting, and with that it builds the session to my measure. It can teach in three ways depending on the day: guided (it walks me through step by step), by challenge (it hands me the problem and the success criteria, and I get my hands dirty in the code), or by reading (it curates articles and asks me questions, ideal for the phone).
• end-learn is the only one that writes the trail of the session: the log, the updated state, and the insights. And it doesn’t do it silently: first it shows me a summary and waits for my confirmation.

Notice one thing in the diagram: almost all the arrows that write come out of end-learn, and almost all the ones that get consulted go into learn. That asymmetry is the entire system. learn reads the past to prepare the present; end-learn turns the present into past for next time. What travels between the two underneath — insights.md — is what keeps the system from starting from zero every day.

The trick is in how I move from one session to the next

What turns this into a system and not a collection of commands is two details that tackle the continuity problem head-on:

The first: silent observation and debrief

During the session, the AI quietly notes where I asked for a hint, what was hard, what I nailed on the first try, and what question I left hanging. It doesn’t show me those notes while I work — they’d distract me. On closing, it synthesizes them into a summary that I review and correct. I could have asked the user to fill in that summary themselves, but I deliberately didn’t: nobody self-assesses well, least of all at the end of a session when all you want is to wrap up. The system observes while you work, and you only validate.

The second: a layer that learns how you learn

When I finish a session, the intelligence layer updates insights.md with the topics that keep coming up as difficulties, the ones I can already consider mastered, and the level trend in each gap. And when I start the next one, that same layer reads the history before starting and passes the context to the new session. The concrete effect: if “async error handling” gave me trouble in two different lessons, next time the system brings it up at the start — “this was left shaky, do we spend five minutes on it or go straight in?” And if I’ve spent three sessions on a topic, it raises the level on its own and skips the beginner scaffolding.

This is what the generic chat can’t do. It’s not that it “remembers” the previous conversation: it’s that it distills a model of how I learn and uses it to tune the next session.

The 30-minute problem

Back to the pain from the start: short sessions that the context switch devours. The system’s answer is twofold. The profile stores my real session length — in my case, 30 minutes — and learn breaks each lesson into milestones that fit in that gap, instead of proposing a three-hour project I’ll never start. And since only one lesson is active at a time, picking back up doesn’t mean remembering where I left off: the current.md file already knows. I open it, it tells me “you were on milestone 2 of 4, your last session was Tuesday,” and I carry on. The context switch stops being a toll.

I also assumed from the start that not everything gets finished, and that’s fine. A lesson can stay in_progress, be marked completed, be parked as postponed, or be dropped entirely (abandoned). Modeling abandonment as a first-class state, and not as a failure, avoids the graveyard of half-finished courses we all drag around: if something stopped interesting me, I close it with its reason, and the system stops proposing it.

And no, this doesn’t make me learn faster

At this point, it’s worth stressing something: this system doesn’t make me learn faster, nor does it spare me the effort of understanding things. It’s not a shortcut. What it does is clear away the friction that kept me from starting: the “I don’t know what to study,” the “I don’t remember where I left off,” and the “half my session goes to rebuilding the context.”

It’s not a product either. It’s a personal tool, built around how I learn, and it leans on the AI’s observation being reasonably accurate — that’s why the debrief confirmation step isn’t optional, it’s the safety net. But the underlying change is the one I was after from the very first line of this article: turning AI from a chat that forgets you into something that accumulates. And, with that, dropping the usual excuse.

Don’t forget to learn.

Even though I built them for myself, these skills are available to anyone who wants to try them: they come inside the orbitant-os plugin. If you use them, tune them to how you learn: that’s exactly the point.