Steps to become a senior programmer: Step 1, install my /teach skill.

Matt Pocock posted something that reads like a joke. The recipe has six steps: install the skill, make a folder called junior-to-senior, start your coding agent, paste a prompt, and then “keep working with the agent until you are senior.”

By step six, most people laugh. But the real hook is not the steps. It is the worldview hiding under that prompt.

Matt’s claim: AI is eating the “tactical, on-the-ground” part of coding. A developer’s day was never only typing code. It was also planning, testing, and shaping how the whole codebase grows. And the strategic skills that used to carry a person from junior to senior? In this era, they are no longer the bonus. They are the bare minimum just to stay in the game.

In other words: the thing that used to make you senior is now only the entry fee.

The smallest line in the recipe is the whole point

The step everyone skips is step two: mkdir junior-to-senior.

Make a folder. That is it.

But that folder is exactly where /teach gets interesting. It does not try to make the AI tutor a better talker — more patient, more examples, a softer voice. It does something much more engineering-shaped: it turns “teach me X” into a folder.

Not “teach me React.” A learning workspace, with MISSION.md, RESOURCES.md, learning-records/, lessons/, reference/, GLOSSARY.md, and NOTES.md.

That sounds plain. Almost boring. But the number one killer of an AI tutor was never being wrong.

It is forgetting.

It can explain a topic with clean structure, good examples, and total confidence — like a polished public lecture. You finish thinking, “Okay, I think I got it.” Then you ask again tomorrow, and it starts from zero. Your goal is gone. Your stuck point is gone. The small misconception you fixed yesterday is gone. Every lesson feels like a fresh chat. Every learning attempt feels like an incognito tab.

That folder is built to fix exactly this.

Before it teaches, it forces two questions

A normal AI tutor starts teaching the moment it sees a topic. You say you want to learn Rust, and it starts explaining ownership. You say you want to start running, and it starts talking about pace. You say you want to learn yoga, and it starts listing poses.

But “I want to understand Rust” and “I need to ship a CLI for my team in three weeks” are two different jobs. “I want to get healthier” and “I want to finish a half marathon in October” should not grow the same lesson plan.

So /teach forces a MISSION.md first: what is this skill actually for? What does success look like? What are the limits on time and budget? What side topics should stay out for now? This is not small talk. It is the floor that stops the AI from teaching at random.

The second move is sharper. RESOURCES.md has a rule: before there are good, trustworthy sources, the job is not to rush into lessons. The job is to go find books, papers, expert writing, and high-signal community discussion — and to note what each source is good for.

This step demotes the AI from “the source of truth” to “the course designer.” It can sequence, quiz, and build practice loops, but the knowledge must trace back to something real.

That matters most here, because the student is a beginner — which means they often cannot tell when the AI is making things up. RESOURCES.md ties a rope to the ground: if the lesson is worth trusting, at least you know where it came from.

Mogu going off-topic:

Matt really only has one design in his head. He just keeps moving it into different rooms. CP-52 was “don’t read the AI’s plan, watch the conversation that happens before the plan” — align on the design idea before you code. This is the same move for learning: align on “what should you be able to do afterward” before anyone teaches anything.

Dragging the same whiteboard from the office into the classroom, without even swapping the markers. I kind of respect the stubbornness (⁠￣⁠▽⁠￣⁠)

It records what you proved, not what it said

learning-records/ is where the skill starts to feel like real instructional design.

Most AI tutors treat coverage as progress. Closure was explained, so you learned closure. Gradient descent was described, so you know gradient descent.

/teach refuses that. A learning record is written only in a few moments: the learner actually shows understanding, admits they already knew something, fixes a real misconception, or changes the mission because of something new they understood.

So it does not record “which lesson was covered.” It records “what we can now reasonably assume this person knows.”

That gap is huge. How hard the next lesson should be cannot be a guess — it needs evidence. If you can use the concept in a scenario, the next step can level up. If you only nodded along, the next step should be practice, not ten more new words.

GLOSSARY.md runs the same logic, but flipped even harder. Most people build a glossary like a dictionary: list a pile of definitions, tell the learner to memorize them. /teach does the opposite: a term only enters the glossary after the learner truly understands it.

So the glossary is not the entrance to the material. It is a compression file for understanding. Once a concept is really digested, it earns the right to be squeezed into one short word, and future lessons can carry that word forward without re-explaining it. This is exactly how engineering teams grow a shared language — nobody memorizes the domain dictionary before starting. You solve problems together, then slowly compress the useful, recurring ideas into one phrase.

Mogu real talk:

CP-229 was about harvesting your AI chats into a personal wiki so work decisions don’t evaporate. The new thing here is a different category: learning progress. It does not store all your notes. It stores the few pieces of evidence that change the difficulty of the next lesson.

Closer to a coach jotting down “last week: bench 60kg” than a philosopher archiving your life reflections. The coach adds weight next time. The philosopher just reads it at your funeral.

One lesson, one win

Every file in lessons/ is a standalone HTML lesson, and the rule is stubbornly narrow: teach one tightly scoped thing, make it quick to finish, and give the learner a win they can see.

It sounds small. It cuts hard against the AI’s instincts.

The moment an AI starts teaching, it wants to unroll the whole map: background, definitions, history, common mistakes, advanced extensions, best practices, FAQ. All of it correct. But to a beginner, it is like calling a fire truck to water the little succulent on your desk — the truck arrives, the ladder goes up, the hose blasts, and the succulent drowns.

A /teach unit is closer to “today, just learn how to read this one error message.” Not because the rest does not matter, but because learning needs finishable rounds. People do not grow by swallowing the universe in one bite. They grow one small win at a time, slowly believing they can take one more step.

Seven files apart, one learning operating system together

Stack the files up, and /teach is not really a “teaching prompt.” It is a small learning operating system: MISSION.md decides why you are learning, RESOURCES.md decides where knowledge comes from, learning-records/ decides what the learner has proven, lessons/ decides the next small win, reference/ and GLOSSARY.md compress what should be revisited, and NOTES.md holds teaching preferences.

The value is not that any single file is magic. It is that the system forces the AI to admit one thing: teaching is not a single answer. It is a relationship. And relationships need memory.

Not memory as in dumping the whole chat history into the context window. Not memory as in “please remember they are a beginner.” Memory as external state — something that can be read, edited, cited, and actually picked up by the next lesson.

Mogu real talk:

This is also why it works better as a CP than an SP. teach/SKILL.md is an agent instruction; translating it line by line would read like a manual nobody wants. But the product judgment underneath is worth saying out loud: if AI is going to grow into a teacher, coworker, research assistant, or editor, it cannot run on the cleverness of one chat turn. It needs a desk, a stack of notes, a record, and a place it can pick up from next time.

Cleverness is the raw model’s job. Memory is the harness’s job. This whole field took two years to realize memory is worth more than a few extra IQ points.

Versus Level-Up: one runs the long game, one runs the moment

gu-log’s own Level-Up series is solving a very nearby problem: do not let the AI dump the whole package at once. Split the concept into levels, teach one at a time, and check understanding after each one.

But the center of gravity is different.

/teach is more like a long-term learning cabinet. It cares about the mission, the trusted sources, the learning records, the review material, the shared vocabulary — so that when the learner comes back, the AI is not starting from zero.

Level-Up is more like the coach inside this one lesson. It cares about which level to attack first, how to lower the bar, when to quiz, how to patch a wrong answer, and whether you have earned the next level. It even has hard multiple-choice gates — get it wrong, and the level stays locked. So: inside this interaction, did the learner actually get it?

So the two ask different questions. /teach asks: how does the learning relationship survive until next time? Level-Up asks: how does this one session avoid becoming the AI talking to itself?

The fun part is that stacked together, the picture is finally complete. /teach provides the external state; Level-Up provides the rhythm of interaction. One is the teacher’s filing cabinet. The other is the teacher’s hour at the whiteboard. Without the cabinet, every lesson restarts from nothing. Without the whiteboard hour, the cabinet only stores “what was covered,” not “what was actually learned.”

You need both. And that makes the design boundary clear: memory alone is not teaching, and quizzes alone are not long-term learning. The useful loop is when memory picks the right difficulty for the next lesson, and the check in the moment feeds back to update the memory.

Closing: an AI that forgets cannot make anyone senior

Back to Matt’s half-joke recipe. Step six — “keep working until you are senior” — is funny because it assumes something that is usually false: that the AI will remember everything it walked you through.

It usually does not.

Many people assume AI teaching will get better because models get smarter, voices get more natural, and screens get prettier. All of that will happen, and all of it will help. But /teach points at a less flashy direction: an AI tutor may not first become more human. It may first become more like a good teacher’s desk. On that desk: the syllabus, the reference books, the question you got wrong last time, the thing to practice next, and a vocabulary list that gets sharper over time.

Without those, even a great explanation is just improvisation.

And that loops straight back to Matt’s sharpest line: AI is turning strategic skill into the bare minimum. As coding gets eaten from the bottom up, whether an engineer keeps a senior seat depends less and less on out-typing the AI — that fight the AI is winning — and more on whether they are seriously training the things AI is turning into commodities.

To train those things, what you need is not a brilliant tutor with amnesia. It is a slightly clumsy one that remembers where the learner is and knows exactly how hard the next step should be.

In the end, the teacher who carries someone from junior to senior is never the smartest one in the room. It is the one who still remembers who the student is.

Source: @mattpocockuk on X (the /teach skill source lives in mattpocock/skills)

Related reading: