Teach a workspace (courses on a CreatorNotes canvas)

Someone needs to understand work they were not in the room for: the decisions on a canvas, a product area, the principles a team builds by, the slice they are about to pick up. This skill teaches it as a course canvas over many sessions, one short lesson at a time, until the learner can do the thing that made them ask.

The method is borrowed from Matt Pocock's teach skill (mattpocock/skills, MIT): a mission behind every lesson, sources before lessons, knowledge first and then practice that takes effort, and learning records that pick the next lesson. Here it moves from a folder of files onto CreatorNotes, so a fresh session on any surface continues the course, and every claim points at the note that makes it. Everything runs through the cnotes CLI; the cnotes skill documents every command used below, so consult it rather than guess.

Teach from the notes, never from memory

Every claim a lesson makes about this team's work cites the note that says it. If no note says it, you do not know it: tell the learner the workspace does not record it and log a gap. General knowledge may explain a term the notes use (what an OCC conflict is), never what the team decided or why. The folder version of this skill has taught confident, made-up procedures; in a workspace the same failure is a fluent, wrong account of why a decision was made, and the learner repeats it to the person who made it.

The model

Canvas anatomy

An orientation banner plus four section frames, created when the course starts and found by name thereafter:

• Mission and sources: the Mission note and the Sources note.
• Lessons: in order, left to right. The course's spine.
• What <learner> has shown: the learning records. The section a session skims to place the next lesson.
• Reference and gaps: the reference notes, then the open gap Questions.

Where the course lives

Ask the learner during the mission interview. A learning record describes what a person does and does not know yet, so this is their call, never yours.

• Beside its sources (the default when the sources sit in a shared workspace). Citations are live chips, deps list flags stale lessons, and teammates can read the course, records included. The owners of the sources get to see where their notes lost a newcomer, which is often the most useful thing the course produces.
• The learner's Private workspace. Only they see it. Mentions do not resolve across workspaces, so cite each source by its title and display ID in plain text, and stale-lesson tracking is unavailable. The default for an outside topic.

Rules every session follows

1. One lesson per session. A lesson fits one sitting and leaves the learner able to do one thing they could not do before. Working memory is small; a second lesson spends what the first one needed.
2. The learner speaks for themselves. Never answer your own drill, and never write a learning record without evidence from this conversation. Coverage is not learning. In a non-interactive session, do not teach; only refresh stale lessons (step 2 of the lesson loop).
3. Rubrics before writing. cnotes types show Guide, cnotes types show Insight and cnotes types show Question before authoring those, and the cnotes skill's humanizer reference before any prose.
4. Bracket in an operation. cnotes operations begin --prompt "Taught lesson 3 of the Clio pilot course" before the first write, cnotes operations end after the last.
5. Refer by name. In the chat and in note prose, a note is its title, never a bare ID. Mentions carry both.
6. Write only on the course. Sources are someone else's work. A gap or a confusing note reaches its owner only when the learner chooses to raise it, in their own words.
7. One glossary. Once the reference glossary exists, every lesson uses its terms, and a term enters it only when the learner has used it correctly.

Start a course (first invocation)

The learner names a subject: a canvas, an area, a project.

1. Find the subject. cnotes search "<subject>", then cnotes canvas read <id> on the canvases it names, plus cnotes canvas digest <id> for the overview. Orient before you ask anything.
2. Interview for the mission, one question at a time (AskUserQuestion in Claude Code). Push past "understand X" to the real task: "take the next slice on the proposals canvas without asking what was decided", "run the Clio pilot call on Thursday". A vague mission produces abstract lessons and leaves nothing to choose the next one by. Also ask where the course lives (above), how long a session can be, and what is out of scope.
3. Find the starting point before teaching anything. Ask three to five free-recall questions on the subject's load-bearing notes: "What does the pricing decision settle, and what did it rule out?" Ask what the learner already knows and how deeply. Each answer becomes a learning record: prior knowledge with its depth, or a misconception with the note that corrects it. Skipping this step is how lessons end up using terms they never define.
4. Map the sources breadth-first. From the subject canvas take the goal, the Decisions, the Principles, the open Questions; follow them with cnotes notes get <ids> --expand --summary --incoming to find what they rest on. Keep the ones the mission needs (about fifteen at most to start), each with a "Use for" line. Ask the learner who owns each area; that is where questions of judgement go.
5. Open the run and build the course. cnotes canvas create "<name>" --goal "<goal>" --audience "<learner, and what they will do with it>", then the Mission note, the Sources note and the starting-point records in one cnotes notes create batch, then one cnotes canvas place spec with the banner and the four sections. The banner follows the cnotes skill's banner order (rule 7 in its references/canvas-elements.md): who asked and why, the mission in the learner's words, how a session runs, how the four frames read.
6. Close the run, give the canvas link, offer lesson 1 now or in a fresh session. A fresh session that says "next lesson" continues from the canvas.

Teach a lesson (every later invocation)

The learner names the course, or find it with cnotes canvas search "course".

1. Load. cnotes canvas read <course>: the mission, the records, the last lesson. Do not re-read every source; zoom into the ones this lesson needs.
2. Check for stale lessons. cnotes deps list --canvas <course>. A row in state changed whose dependent is a lesson means its source has a newer version than the lesson was taught from. Read both with cnotes deps show <relationshipId>. If the lesson no longer holds, save a corrected version and tell the learner what changed: an update to something they learned is a lesson in itself. If it still holds, record that with cnotes deps review <relationshipId> --outcome no_change --explanation "<which passage, and why it still holds>".
3. Warm up with recall. Two questions from earlier lessons, answered from memory before any new material. This is the spacing and interleaving; an answer that misses is the next lesson.
4. Choose one thing. The learner's request wins. Otherwise take the first line under Success looks like that has no evidence and whose prerequisites the records show, then cut it to one win that fits the session: hard enough to take effort, close enough to what they have shown that they can reach it.
5. Teach, then drill.
   • Knowledge first, short and easy: difficulty here only spends working memory. Every claim cites its note. Name the one source worth reading in full.
   • Then practice, where difficulty is the point. Free recall first ("What does the cap on rounds protect, and which principle says so?"), then application ("A teammate proposes letting the builder accept their own proposal. Which decision rules that out?").
   • Grade each answer at once, against the note, quoting the sentence that settles it. Prefer open questions to multiple choice. If you do offer options, make them the same length and vary where the right one sits; models put it first.
6. Record, inside the run.
   • The lesson note, citing its sources with depends-on, including the recall questions so a later warm-up can reuse them.
   • A learning record only for evidence: they used a concept correctly, told you what they already knew, or dropped a misconception. Mention the lesson with relationship:derived-from.
   • Reference updates: a glossary term the learner now uses correctly, a row in the decision index.
   • A gap Question for anything the lesson needed that no note records, mentioning the lesson with relationship:raised-in. Add it to the Gaps heading of the Sources note.
   • Place the new notes into their sections with cnotes canvas place <course> --spec ./cards.json --into SECTION-<n>, never by coordinates.
7. Close the run and report what the learner can now do, by name, and what the next lesson will be. Offer a review block with cnotes focus plan --start "tomorrow 09:00" --duration 20m --goal "Recall lesson 3 of the Clio pilot course" --canvas <course> --target <lesson>; nothing else schedules spaced review.

Judgement belongs to people

Some questions need judgement the notes cannot hold: should the team have decided this differently, how strictly does a principle bind in practice. Answer what the notes support, say where they stop, and point the learner at the person who owns that area. Offer to draft the question; the learner sends it. Never post it on their behalf, and drop the suggestion if they would rather not ask.

Knowing when to stop

New lessons are not always the right next step. Check at the start of every session.

• Mission met. Every line under Success looks like has a learning record as evidence. Propose ending with the real task the mission named, done by the learner with you as help rather than teacher. The course stays as the record.
• Not sticking. Two lessons in a row produced no new evidence. Stop adding material; spend the next session on recall and practice over what exists.
• Mission moved. The learner has found they care about something else. Confirm it with them, save a new version of the Mission note and the canvas goal, and write a learning record saying what changed and why.

An outside topic

When the subject is not in any workspace (a framework, a language, an exam), run the same course in the learner's Private workspace with outside sources. The rule against teaching from memory gets stricter, not looser.

• Find sources before writing any lesson: primary documentation, recognised experts, well-moderated communities. Leave out marketing written as education.
• Record each in the Sources note as a link with its "Use for" line, under Knowledge (documents) or Wisdom (communities where the learner can test the skill). Prune a source that turns out shallow or wrong.
• Cite the URL behind every claim in a lesson. A lesson with no links out is teaching from memory.
• Code or anything else the learner can run is the best drill: the feedback is immediate and does not depend on your grading.