MONK, Tutor Mode

Learning a tool like Claude Code is hard. It has dozens of functions and concepts, and they arrive faster than anyone can read about them.

The usual answer is a tutorial or a manual. You stop working, go somewhere else, read about a feature out of context, and forget it. People do not learn a tool that way.

There is a second problem. Tools now do a great deal in the background. The work gets done, and you learn nothing from it. Concepts that would genuinely help you later pass by without you ever seeing them.

So the question I set myself was this. How do you reveal those hidden concepts, and teach them the way a good teacher would?

A good teacher listens to the student. They know what motivates them. They know what the student already understands and what they do not. They translate a new idea into something the student already cares about. And they check, later, whether the student actually uses it, because using something once is not learning it.

That is what I try to do when I teach. So I took those habits and turned them into a system. Every row below is a teaching behaviour on the left and the thing MONK actually does on the right.

What a good teacher does	What MONK does
Listens before speaking	Reads your live conversation with Claude Code, not a profile you filled in once
Knows what motivates the student	Knows the project you are on and what you said you are building toward, and asks when it does not
Knows what they already understand	Keeps two lists: what you asked for yourself, and what Claude did without being asked
Translates the idea into something they care about	Names the concept in terms of the task in front of you, never as a general tip
Picks the moment	Scores every possible thing to say and stays quiet unless it clears the bar
Checks later whether it stuck	Watches for weeks and only counts a concept when you use it again on your own
Does not lecture	One sentence, out loud

Silent features

As AI systems become more capable, people use only a fraction of what they can do, because they do not know what is possible. And when an agent handles complex work on its own, the person can slide into watching rather than learning.

I checked the scale of that on myself instead of guessing. Over forty days, Claude Code used its skills for me 3,014 times. I asked for 73 of them.

Proactive

You cannot ask for something you do not know exists. So waiting for people to ask is not neutral. It only helps the ones who already know the words.

That is why the companion speaks first. It speaks at the moment a concept is about to be useful, rather than waiting for you to ask for something you have never heard of.

MONK sits next to Claude Code.

First, the concept library

I scraped Claude Code’s own tutorials and documentation and turned them into a library of 51 concepts. Each one has a name, what it is for, and the phrases that signal someone is reaching for it. This library is the syllabus. It is plain data, so adding a new Claude Code feature means editing a file.

It watches

A small hook sees each prompt you send. It reads your conversation with Claude.

It keeps two lists

One list is what you asked for. The other is what Claude did without being asked.

The second list is what to teach you. Anything you already do yourself gets removed. You do not need a teacher for a habit you already have.

It decides whether to speak

This is the part I care about most.

Everything MONK could say becomes one kind of object. One formula scores it. How much does it matter? How fresh is it? Does it relate to what you are doing right now? Does anything else support it?

score = importance × freshness × relevance now  +  support
high enough → speak
lower → a small light
usually → nothing

The bar moves. When you are deep in work, it goes up. Only something urgent gets through. When your mind is free, it comes down, and a smaller thing can surface.

Most of the time nothing gets through. MONK says nothing. Silence is the normal outcome, and it is what makes the rare sentence worth hearing.

I learned this the hard way. An early version interrupted me with a quiz while I was working. I told the model not to do that. It did it again. So I removed the quiz from its prompt completely. Then it stopped. You cannot ask a system to be polite. You have to build it that way.

It says one thing

Out loud, because reading is another interruption. One sentence. About what you are doing. Easy to ignore.

You can say yes

Then it runs. In your project, on your machine, on screen so you can watch. Nothing runs until you confirm it. If it would change files, it asks about that folder first.

Then it checks if you learned it

I track whether the concept became a habit. Did you use it again later, on your own?

Accepting a suggestion once does not mean you learned it. Using it again next month, without being told, is learning. So MONK keeps watching for weeks. It only counts the skill when it comes back by itself.

Being proactive does not mean being loud. MONK has levels, and the level is chosen by arithmetic rather than by mood.

Everything it could say becomes one object in a register. Each is scored: how much it matters, how fresh it is, how well it fits what you are doing this minute, and whether anything else supports it. That score is then compared against a threshold, and the threshold moves with you. Deep in work, it rises. Idle, it falls.

score = importance x freshness x relevance now  +  support

score >> threshold   ->  it calls you
score >  threshold   ->  one spoken sentence
score ~  threshold   ->  a written card
score <  threshold   ->  a small light in the corner
below that          ->  nothing at all

It calls you

Reserved for things that are useless late: a scheduled session, a reminder you set, a promise you made to yourself. A phone call is the loudest thing a companion can do, so it has to clear the highest bar.

It says one sentence

The normal teaching moment. A concept fits what you just did, so MONK says so out loud, once, and stops. You can press play again or open it.

It writes a card

Worth showing, not worth interrupting for. The card waits with the concept and a ready-to-run prompt inside it.

It glows

A light in the corner of the small window. It answers if you ask. It never speaks first. This is where most things end up.

It says nothing

The most common outcome by a wide margin, and the one that makes the others tolerable. A tutor that speaks at every opportunity gets switched off.

I design, I teach, and I code. So I started from how I learn and how I teach, turned that into a set of concepts, and built MONK to work that way.

I teach. I lecture at Stanford and at other universities, and I build tools that students actually use. Teaching lets me see and develop principles, and I apply them later in software development.

And I build. FileMap, Asvalin, Voxitect, Basic Tools and Brixel are mine, which is why the tutor is designed to sit beside real software rather than replace it.

Asvalin2026 Brixel2026 Voxitect2026 Basic Tools2026

Designing for designers and design students let me test these ideas in university settings and improve them.

It never acts alone. It offers. You decide. Anything that runs goes through a confirm step you can see.

It is proactive, and it varies how loudly it speaks. Speaking is not one setting. How it reaches you depends on how much the moment is worth, and most moments are worth nothing at all.

It shows you what was hidden. The thing Claude just did for you invisibly is the thing MONK names.

It asks instead of concluding. MONK knows what you said you are working toward. It asks you to connect today’s task to that, in your own words.

Success means you need it less. A skill only counts when you use it without being told. If MONK works, it talks to you less over time.

Teach inside the work

Video games teach you while you play. Same idea. The lesson arrives about the thing you are doing, while you are doing it.

You cannot ask for what you do not know

So MONK speaks first, rather than waiting to be asked. This is why the hidden list is the syllabus. And why MONK speaks instead of waiting.

Doing it once is not learning it

Using something once is not learning it. Learning means it became a habit. So the only thing I count is whether the concept turned into a reflex: you reach for it again next month, in another project, without being told.

Earn the right to be specific

A human teacher earns the right to be precise by first showing they know you. So MONK starts with the connection: your project, what you did yesterday, then names the skill after. If there is no honest connection, it stays general instead of faking one.

The waiting minutes, not built yet

Some tasks run for ten minutes and you sit there. MONK could use that time: prepare you for what is about to land, and help you say out loud what you are expecting, so the thought is already formed when the result arrives. Sometimes the idea arrives while the expectation is still fresh. I have not built this.

What you learn should travel

A skill you used in one project gets offered in another where it fits. A skill you only ever use in one project is a skill you half know.

I track whether you use these skills again after seeing them.

That is the main number. MONK suggested a skill. Weeks later, did you use it yourself, in another project, with nobody asking? I compare that against skills MONK never mentioned. That tells me whether it was teaching or coincidence.

Two more things I watch. Does the list of things left to teach get shorter? And are people dismissing more suggestions over time? Rising dismissals mean a failing tutor, even if some people still say yes.

One more that is easy to miss. How often does MONK stay quiet? If it talks more as weeks pass, it is getting worse.

My starting point is in the repository. Three skills out of fifty genuinely learned in 39 days, with no tutor. That is the number to beat.

Resonance, then repetition

What you are doing matches a few concepts, not the whole library. Those few are the only ones worth saying out loud. Use one enough times and it stops needing to be suggested.

The idea is to build learning on top of what the system already knows about you, gathered over long periods. That is why it is a voice companion that stays with you, rather than a feature inside one app.

The more context we have about a person, the better we can make a subject resonate with them. Sometimes the subject is how to use a particular function. Often it is more complicated than that.

Good teachers are good because they know the student. They can connect a subject to what excites that person, to their goals and their difficulties, and adjust the material accordingly. They look at the whole person, not only the task in front of them.

You cannot do that from inside one tool. If we only ever look at the software in front of us, the teaching stays narrow. Sometimes one well-aimed suggestion changes everything:

Hey Jack, a week ago you mentioned you had become interested in planes and how they work. Yesterday you said you like to think visually and to hear things explained. I can show you how to build a small narrated presentation of how a plane works. You would learn the subject, and you would also learn a visual method you can use on other projects.

Making that bridge can change how someone frames a subject entirely. For that one example, the companion has to do three things. Register the interest. Bridge the gap. Deliver. A teaching module inside a single app cannot see any of that.

There is a second reason this scales. MONK becomes the way you sign in, and the thing that carries your context between tools.

Say MONK is the sign-in for a recruiting platform. Instead of building a profile from nothing, MONK already knows your motivations, your projects, your current interests, your goals and your skills. With your consent it translates those into the platform’s terms. If the platform needs more, it asks through MONK, which puts the question in language you already use.

My prediction is this. In the same way we now sign in with Google or Microsoft, we will sign in with a companion that carries our context between platforms, and we will choose what to share each time. People will trust it with more of their context each year, because it keeps being useful with what it already has.

The engineering supports that. The expensive part almost never runs: deciding whether something is worth saying is arithmetic over logs the product already writes, and a model is used once per suggestion, only to word it. The library is data, not code, so a new feature is a file update. Each person’s history is one small file, and the did-it-stick check runs overnight.

Any tool, not just Claude Code

The library is swappable. The engine does not know what it is teaching. Point it at a 3ds Max library, a SketchUp library, Word, Photoshop, Blender or Asvalin, and the same machine teaches those instead.

This is where it goes next. Each vendor knows their own software better than anyone else, so each vendor maintains their own library and ships a lesson at the same moment they ship a feature. The tutor speaks one protocol, pulls whichever library matches the app in front of you, and updates itself.

Click a vendor to change the app you are working in.