init
/init
Tworzy repozytorium nauki, dodaje do niego przedmioty i łączy je z projektami, z których się uczysz, a także synchronizuje zdalnie.
- Autor
- rafagomes ↗
- Repozytorium
- learning-workflow ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 05.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 13
- Skrypty
- 1
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 05.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
- 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
Skrypty: templates/repo/tools/guard.sh
Co robi i kiedy
Tworzy repozytorium nauki, dodaje do niego przedmioty i łączy je z projektami, z których się uczysz, a także synchronizuje zdalnie.
Wyzwalacze z opisu
Argumenty
/init [subject] [project paths...] | add <project path> | migrate [path] | remote
Oryginalny opis (EN)
Create the learning repo and add a subject to it as its own folder, link the projects a subject learns from, migrate an older one-repo-per-subject learning repo into it, or give the learning repo a private remote so it syncs across machines. Use when the user says 'set up learning for <projects or subject>', 'start a learning repo', 'add <subject> to my learning', 'I want to learn while building X', 'add this project to my learning', 'migrate my learning repo', 'sync my learning repo across machines', or runs another /learn skill and no learning repo is registered yet. One learning repo holds
Jak działa
- 1. Mode
- 2. Ask only what is missing
- 3. Create the learning repo (first time only)
- 4. Add the subject folder
- 5. Link a project
- 6. Migrate a standalone repo
- Data policy (applies to every linked project)
- Sync (every /learn skill)
- Questions and examples (every study skill)
- Registry
Podgląd SKILL.md
---
name: init
description: "Create the learning repo and add a subject to it as its own folder, link the projects a subject learns from, migrate an older one-repo-per-subject learning repo into it, or give the learning repo a private remote so it syncs across machines. Use when the user says 'set up learning for <projects or subject>', 'start a learning repo', 'add <subject> to my learning', 'I want to learn while building X', 'add this project to my learning', 'migrate my learning repo', 'sync my learning repo across machines', or runs another /learn skill and no learning repo is registered yet. One learning repo holds every subject; it never lives inside a project."
argument-hint: "[subject] [project paths...] | add <project path> | migrate [path] | remote"
---
Create the learning repo, add a subject, link a project, migrate, or add a remote. Argument: $ARGUMENTS
The **learning repo** is one private git repo per learner. It holds every subject the learner studies (e.g. `python`, `rust`, `machine-learning`, `statistics`, `music-theory`), each in its own **subject folder** with its curriculum, lessons, exercises, quizzes, flashcards and reflections. The **projects** hold the real code and data. Each subject links any number of projects, from work repos and personal repos alike. Links are by reference only, so every project stays clean and the learning stays private.
```
<learning repo>/ default ~/Learning
├── README.md index of subjects
├── CLAUDE.md .gitignore
├── tools/guard.sh tools/hooks/pre-commit
└── <subject>/
├── LEARNING.md PROGRESS.md
├── curriculum/ plans/ builds/ lessons/ reflections/
├── flashcards/deck.md
└── scratch/ gitignored
```
## 1. Mode
When the registry already has a learning repo on disk, pull it first, as **Sync** below says, before reading anything from it (every mode). When it has none, ask the location first (step 2.3): if that is already a learning repo, such as a clone from another machine, register it (see **A clone from another machine** in step 3) and continue only with what the argument asked for (a subject, `add`, `remote`); with nothing more, report the registered subjects and stop.
- `add <project path>` or "add this project": **link a project** to an existing subject (resolve it as below; ask which one if several). Skip to step 5.
- `migrate [path]` or "migrate my learning repo": **fold a standalone repo** from v0.1.0 (one git repo per subject) into the learning repo. Skip to step 6.
- `remote` or "sync my learning repo": **add a remote** to the registered learning repo (see **Remote** in step 3; none registered: offer `/learn:init <subject>`). With `origin` already set, check it before any push: it must be a GitHub repo (`git -C <learning repo> remote get-url origin` names `github.com/<owner>/<name>`) and `gh repo view <owner>/<name> --json visibility` must print `PRIVATE`. If it isn't on GitHub, can't be checked, or isn't private, stop and tell the learner why; never push. Otherwise make sure the current branch tracks it (`git -C <learning repo> push -u origin <branch>`) and report its URL. Then stop.
- Otherwise: **add a subject**. Check the registry first:
- The subject is already registered inside the learning repo: offer to link the new projects to it instead.
- It is registered as a **standalone** repo (see Registry: its folder is its own git root): offer `migrate` instead of creating a second one.
- The registry has no `repo` but has standalone entries: create the learning repo (step 3), then offer to migrate each standalone entry.
## 2. Ask only what is missing
Use AskUserQuestion for anything the argument doesn't give:
1. **Subject and slug** (e.g. `python`, `distributed-systems`). The slug is the folder name: lowercase letters, digits and hyphens (`^[a-z0-9][a-z0-9-]*$`) and not `tools`. Step 4 also checks it against the root `.gitignore`.
2. **Projects to link**: paths to git repos. Offer the current repo if the session is inside one. Zero is fine (a pure-subject folder); more can be added later with `add`.
3. **Location of the learning repo**, only when the registry has no `repo` yet. Default `~/Learning`. Never inside a project.
4. **Learner profile** for this subject: current level (new / some experience / working knowledge), preferred depth (practical first / theory first / balanced), lesson language, and the default **hands-on level** for build mode: `claude` (Claude codes and explains), `adaptive` (Claude writes plumbing, the learner writes the core), or `you` (the learner codes, Claude coaches). When another subject exists, offer its language and hands-on level as the default.
5. **Toolchain** for labs and exercises: propose the default for the subject from this skill's `toolchains.md` (or detect it from a linked project's manifest: `pyproject.toml`, `package.json`, `Cargo.toml`, `go.mod`, …) and confirm. Record a run command, a test command, and an in-folder test command for exercises (`toolchains.md` → **Exercises**). Use `none` for subjects without code; labs then become worked problems and exercises become problem sets checked in conversation.
## 3. Create the learning repo (first time only)
Skip when the registry already has a `repo` that exists on disk.
**A clone from another machine.** If the location is already a learning repo (its git top level, with `tools/guard.sh` and a subjects table in `README.md`), don't create anything: first run the `git config core.hooksPath tools/hooks` line below (so the guard covers any commit Sync makes), then pull it (see **Sync**), record `"repo"`, register each subject folder listed in its `README.md` (projects are per machine: offer `/learn:init add <path>` for any it should link here), and continue as step 1 says.
**Check the location first, and move nothing until the whole check passes.** It must not exist, be an empty directory, or hold only v0.1.0 learning repos. v0.1.0 put them at `~/Learning/<slug>`, inside the new default, and `git add -A` would commit them as broken embedded repos. A v0.1.0 learning repo is a folder that is its own git root **and** has a `LEARNING.md` at that root (usually also a registered standalone entry). Anything else in the location (files, plain folders, other git repos such as a course clone or a linked project) means: stop and ask for another location, before moving anything. When the check passes, move each v0.1.0 learning repo aside (see **Moving a standalone repo aside** below) and offer `migrate` for each after the learning repo exists.
### Moving a standalone repo aside
The one rule for a standalone repo that sits inside the learning repo's location (step 3, and migrate when the learning repo already exists around it):
1. `mkdir -p <location>.v0 && mv -T <location>/<name> <location>.v0/<name>`: beside the location, never inside it. If `<location>.v0/<name>` already exists, stop and ask (an earlier attempt or a backup); never move into it.
2. Set its registry entry's `path` to `<location>.v0/<name>`.
3. Repoint active learn mode from the old path to the new one (see **Repointing learn mode**).
4. Tell the learner where it went and that `/learn:init migrate` will bring it in.
### Repointing learn mode
Whenever a subject's registry `path` changes, replace the path it had **before the change** with the new one in every state file in `${LEARNING_WORKFLOW_HOME:-~/.config/learning-workflow}/active/` that names it. Match whole path components: search for and replace `<old path>/` with the trailing slash (`grep -lF "<old path>/"`), so `~/Learning.v0/ml` never rewrites `~/Learning.v0/ml-ops/…`. so the hook, the build wrap-up and `/learn:off` keep writing to the subject's real folder.
### Then create it
Copy this skill's `templates/repo/`:
| Template | Becomes |
|---|---|
| `README.md` | `README.md`: subject index and layout |
| `CLAUDE.md` | `CLAUDE.md`: rules for any Claude session opened in the learning repo or a subject folder |
| `gitignore` | `.gitignore` |
| `tools/guard.sh`, `tools/hooks/pre-commit` | the guard and the hook that runs it |
```bash
git init -b main
chmod +x tools/guard.sh tools/hooks/pre-commit
git config core.hooksPath tools/hooks # repo-local, so a global core.hooksPath can't bypass the guard
git add -A && git commit -m "chore: initialize learning repo"
```
Record `"repo": "<absolute path>"` at the top level of the registry. `core.hooksPath` is local git config, not committed: after cloning the learning repo on another machine, run that `git config` line again (the repo's `CLAUDE.md` says so).
### Remote
Offer (AskUserQuestion) a **private** GitHub remote, recommended so the learning repo syncs across machines and sessions (see **Sync**), or keeping it local-only, which stays a valid choice. Create nothing until the learner confirms.
1. `gh auth status` must pass; otherwise say how to log in (`gh auth login`), keep the repo local-only, and mention `/learn:init remote` for later.
2. Owner: the authenticated account (`gh api user --jq .login`). Name: the learning repo's folder name, lowercased, unless the learner gives one.
3. **Is the name taken?** If `gh repo view <owner>/<name>` succeeds, it is. Ask (AskUserQuestion): **choose another name** for the learning repo (offer two, e.g. `learning-vault` or `<name>-notes`, each checked the same way; Other for their own) or **rename the existing repo**. Say plainly in the question that renaming does not free the name for the learning repo (reusing a renamed repo's old name breaks GitHub's redirect), so the learning repo takes a new name either way; renaming is only for a learner who wants the existing repo renamed anyway, e.g. to keep names coherent.
4. **Renaming the existing repo.** First check what the rename could break, and show what you find: a GitHub Pages site (`gh api repos/<owner>/<name>/pages`; a project site's URL moves with the name and gets no redirect), a hard-coded base path or the repo name in its build config, workflows that name the repo (`.github/workflows/`), webhooks (`gh api repos/<owner>/<name>/hooks`), a `homepage` pointing at it. If it would break anything live, stop and go back to choosing another name. Otherwise rename only after the learner confirms (`gh repo rename <new name> -R <owner>/<name>`). Never create a repo with the old name afterwards: that would break GitHub's redirect from the old name. The learning repo then takes another name: ask for it as in 3.
5. Create it **without pushing**: `gh repo create <owner>/<name> --private`. Check `gh repo view <owner>/<name> --json visibility` prints `PRIVATE`; if not, say so and stop, with nothing pushed. Only then add the remote and push: `git -C <learning repo> remote add origin <its URL from gh repo view --json sshUrl or url>` and `git -C <learning repo> push -u origin <branch>`.
## 4. Add the subject folder
Never overwrite: if `<slug>/` already exists, stop and ask. Then check the slug against the root `.gitignore`: `git -C <learning repo> check-ignore -q <slug>/LEARNING.md` exit 1 means not ignored and is the only pass; exit 0 means ignored (e.g. `build`, `out`, `target`, `scratch`, `node_modules`), so propose a variant (`build-systems`) and ask; any other exit is an error to report. Copy this skill's `templates/subject/`, filling the placeholders:
| Template | Becomes |
|---|---|
| `LEARNING.md` | `<slug>/LEARNING.md`: identity, learner profile, toolchain, linked projects table, data policy |
| `PROGRESS.md` | `<slug>/PROGRESS.md` |
| `deck.md` | `<slug>/flashcards/deck.md` |
Create the empty directories `curriculum/`, `plans/`, `builds/`, `lessons/` and `reflections/` (each with a `.gitkeep`) and `scratch/` inside `<slug>/`. Add a row to the root `README.md` subjects table: `| <Subject> | [<slug>/](<slug>/LEARNING.md) | <date> |`, keeping rows sorted by slug. Register the subject (see Registry) and commit only the subject and the index (`git add <slug> README.md`): `chore(<slug>): add subject`, then push as **Sync** says.
## 5. Link a project
For each project:
- Record its `slug` (repo directory name unless the user names it), absolute path, `git remote get-url origin` (if any), default branch, and **sensitivity**: `work` (employer or client code, the default for repos under an org remote) or `personal`.
- Store path, remote and branch **only in the registry**, in the subject's entry. In the subject's `LEARNING.md` add just a row with the slug, sensitivity and a one-line neutral description, so no absolute paths or work remotes are ever committed.
- Commit: `chore(<subject>): link <project-slug>`, then push as **Sync** says.
A project may be linked to several subjects; each subject records it separately. Sensitivity changes how much may be quoted (see the policy). When in doubt, use `work`.
## 6. Migrate a standalone repo
For a v0.1.0 learning repo that is its own git repo (a `LEARNING.md` at its root, which is its git top level). Resolve it from the argument, the current directory, or the registry's standalone entries (ask which if several). Create the learning repo first (steps 2.3 and 3) if there is none; step 3 moves standalone repos that sit inside its location aside. `<old>` is the standalone repo's registry `path` (after any move) and `<slug>` its slug. v0.1.0 had no slug rule, so apply both checks here: step 2.1's format (`^[a-z0-9][a-z0-9-]*$`, not `tools`) and step 4's `.gitignore` check. If either fails, offer a new slug; the folder and the commit scope use it.
First, if the standalone repo sits **inside the existing learning repo** (e.g. at `<learning repo>/<slug>`, its own git root, showing as `?? <slug>/` in `git status`), move it aside (see **Moving a standalone repo aside**, with `<location>` = the learning repo) and continue from its new path. Then check before touching anything else, and refuse and explain on any failure:
- The standalone repo is clean: `git -C <old> status --porcelain` prints nothing.
- The learning repo is clean: `git status --porcelain` prints nothing (otherwise the migration commit would sweep in unrelated changes).
- `<slug>/` doesn't exist in the learning repo.
- Only the current branch (`git -C <old> branch --show-current`) is migrated. List anything else that would be left behind: other local branches (`git -C <old> branch --format='%(refname:short)'`), stashes (`git -C <old> stash list`) and commits not on any remote (`git -C <old> log --branches --not --remotes --oneline`, when it has a remote). If there are other branches or stashes, show them and continue only when the learner says to leave them behind or has merged them into the current branch.
Then, from the learning repo, keeping the standalone repo's history:
```bash
git fetch <old> <current branch>:refs/learn-migrate/<slug>
git merge -s ours --no-commit --allow-unrelated-histories refs/learn-migrate/<slug>
git read-tree --prefix=<slug>/ -u refs/learn-migrate/<slug>
git rm -rqf --ignore-unmatch <slug>/tools <slug>/.gitignore <slug>/CLAUDE.md # the root ones apply
# customisations (below): write the slimmed <slug>/.gitignore and <slug>/CLAUDE.md if any, then
git add -A -- <slug>
git commit -m "chore(<slug>): migrate subject from its standalone repo"
git update-ref -d refs/learn-migrate/<slug>
```
If any of these fails (for example the guard blocks the commit because gitleaks flags an old file, or a file over 1 MB was committed with `--no-verify` in v0.1.0), undo it and report what blocked it: `git merge --abort; git update-ref -d refs/learn-migrate/<slug>`. The learning repo is then as it was, and the standalone repo was never touched.
**Customisations.** Learner additions are found by comparing with the v0.1.0 templates in this skill's `templates/v0.1.0/` (`gitignore`, `CLAUDE.md`, and `CLAUDE.earlier.md` for repos created by an earlier v0.1.0 build: a line in either template is not an addition), read from the old repo: `git -C <old> show HEAD:.gitignore` and `HEAD:CLAUDE.md`. Lines added to `.gitignore` go into a new `<slug>/.gitignore` holding only those lines (a nested `.gitignore` applies to its folder, so their meaning is unchanged). Rules added to `CLAUDE.md` are shown to the learner and, if they want them, go into a new `<slug>/CLAUDE.md` holding only those rules (Claude Code loads it with the root one). Write these after the `git rm` and stage them with the `git add` line, so the migration commit holds them and the tree ends clean.
Then:
- Copy the standalone repo's `scratch/` (gitignored, so not in its history) to `<slug>/scratch/`. Create the empty directories from step 4 that are missing.
- Fix `<slug>/LEARNING.md` wording that calls it a standalone repo (the title and intro line), add the `README.md` row, and commit: `docs(<slug>): adapt subject to the learning repo`.
- Update the registry entry's `path` from `<old>` to `<learning repo>/<slug>` (keep its projects), and repoint learn mode from `<old>` (see **Repointing learn mode**).
- Check: `git log --oneline` lists the standalone repo's commits under the merge, `<slug>/tools/` does not exist, and `git status --porcelain` prints nothing. (Per-file history before the move sits under the old paths: `git log <merge commit>^2 -- LEARNING.md`.) Only after this check passes, push once, as **Sync** says; never earlier, so an undo never rewrites pushed history.
- Leave the standalone repo untouched. Offer to delete it (and its remote, if any) only after repeating what would be lost with it (the branches, stashes and unpushed commits listed above, and its `scratch/` if not copied), and delete only after the learner confirms.
## Data policy (applies to every linked project)
- Study skills (`curriculum`, `teach`, `practice`, `quiz`, `reflect`, `plan`) treat every project as **read-only**. Lessons cite code as `<project-slug>:path@shortsha` (sha from `git -C <path> rev-parse --short HEAD`).
- **Build mode** (`/learn:build`) is the exception: at the learner's request it codes in the project under that project's own rules (its CLAUDE.md, branches, commits, review). Even then, no learning artefact, learn-mode state, `TODO(learner)` scaffold or reference to the learning repo is ever left in the project.
- `work` projects: cite and paraphrase; quote at most a few lines when the lesson needs them. Never commit their data, schemas with real values, secrets, customer or personal data, or internal URLs and hostnames.
- `personal` projects: code may be quoted freely; data still stays out unless the user says that dataset is public.
- Real data samples for labs go only into the subject's `scratch/` (gitignored). Exercises use **synthetic data** generated by a seeded script in the exercise.
- No project ever references the learning repo. Outside build mode, anything learned that should reach a project is rewritten there through that project's normal workflow (spec, branch, PR).
- Web searches (e.g. `/learn:teach` looking for a short video) use only general field terms: never a project's name, codenames, internal terms or data. A subject can turn videos off in `LEARNING.md` (`Videos in lessons: off`).
- Never loosen this policy unless the user writes the exception themselves; record it in the subject's `LEARNING.md`.
`tools/guard.sh` enforces the mechanical part on the staged content: it blocks data files outside `<subject>/lessons/*/exercises/*/data/` (common config files such as `package.json` are allowed), files over 1 MB, and anything gitleaks flags when gitleaks is installed.
## Sync (every /learn skill)
The learning repo is edited from several machines and sessions, so it syncs like a notes vault: pull before reading, push after every commit. `<repo>` is the git repo that holds the subject folder (for a standalone v0.1.0 repo, that repo). Every skill that reads or writes it does this; `hooks/learn-mode.sh` never does (it must stay fast and silent).
**Pull at session start**, before reading anything from the repo:
1. **No upstream** (`git -C <repo> rev-parse --abbrev-ref @{u}` fails): skip syncing silently, for pull and push alike. A local-only repo is a valid choice; never nag about a missing remote (`/learn:init remote` adds one).
2. **A rebase or merge in progress** (`git -C <repo> status` says so): stop and bring it to the learner.
3. **Uncommitted changes** (`git -C <repo> status --porcelain` prints anything): don't pull over them. Show the list first, then ask (AskUserQuestion):
- **commit them**: one commit per subject folder with changes (`git -C <repo> add -A -- <subject>`, `chore(<subject>): save local changes`), and root files in a separate `chore: save local changes` (staging only those files); the guard runs on each. Then pull;
- **leave them**: continue without pulling, and without pushing, this session. Commits stay local; say so once, in one line, at the end of the session (not per commit).
4. `git -C <repo> pull --rebase`:
- fails and a rebase is in progress: a **conflict**. First capture the conflicting files (`git -C <repo> diff --name-only --diff-filter=U`), then `git -C <repo> rebase --abort`, stop, and bring the conflict to the learner with that list; never resolve it yourself;
- fails otherwise (offline, network, auth): say so in one line and continue on the local copy.
5. If the pull ran and the branch is still ahead of its upstream (`git -C <repo> status -sb` shows `ahead`, e.g. commits from an offline session), push as below.
**Push after every commit** the skill makes to the repo, when there is an upstream and the pull wasn't skipped at step 3: `git -C <repo> push`.
- **Rejected** because the remote moved on: re-check `git -C <repo> status --porcelain` first. If it prints anything (the learner's edits, a lab's output left unstaged), don't pull (no `--autostash`): say in one line that the commit stays local until those changes are dealt with. Otherwise `git -C <repo> pull --rebase` and push once more; a conflict is captured, aborted and brought to the learner, as in step 4.
- **Network failure**: say so in one line; the commit stays local and the next session's pull and push carry it.
- **Never force-push**, and never rewrite pushed history.
## Questions and examples (every study skill)
**Questions.** Every question that asks the learner to answer, predict or explain (a lesson's predictions, "your turn" questions and check, quiz questions, build mode's predictions, "is this clear?" comprehension checks and done-check) is one AskUserQuestion call, so answering is a pick, not typing:
- One question per call; 2–4 short options. Never mark one "(Recommended)", and never let order or wording give the right one away: vary its position, keep options alike in length and tone.
- Distractors are real misconceptions: a swapped formula, the tempting wrong idea, an off-by-one, the confusion just warned about.
- When the question needs data (a table, snippet or output), put it in the options' `preview` as markdown (a linked project's code only within the data policy), the same on each option, or different per option when the options are alternative tables, outputs or code. The learner then sees the data beside the options.
- Where options would give the answer away (explain why, derive), offer approaches or partial claims, and say in the question that typing an explanation via Other is welcome.
- Where a pick is evidence of an ability (a quiz's explain, choose-and-justify and critical questions; every done-check question), it's right only with the right reason: after a right pick, follow up with "why?" (candidate reasons as options, the tempting wrong ones as distractors) or take a typed explanation. The follow-up belongs to the same question and is scored with it, once: right pick and wrong reason is **Partly correct**.
- The automatic Other is the learner's free answer: judge a typed reply as the answer, or, if it's a question ("why…?"), explain or rephrase (a teaching turn, see **Content before the dialog**) and ask again in the next.
- **Verdict first.** Every reply to an answer opens with its verdict in bold, as the very first words: **Correct.**, **Incorrect.** or **Partly correct.** (only for a multi-part answer with some parts right, or a right pick with the wrong reason). Then explain: for Incorrect, the right answer and why the tempting wrong one was tempting; for Partly correct, which part was right and which wasn't. On a question with a "why?" follow-up, a right pick gets no verdict yet: ask why, then give one verdict for both. A prediction is Correct when the result falls within the option picked (so write numeric options as non-overlapping ranges). No hedge stands in for the verdict ("not quite", "close", "half right"); be kind after it. Never soften Incorrect into Partly correct: the verdict said is the one recorded and scored. A typed question gets no verdict.
- **Position.** A counted set of questions (a lesson's Check, a quiz, a done-check) gives its count in the first question's text, `Check · 3 questions · Question 1/3 · …`, and each later question starts with its position, `Question 2/3 · …`. A "why?" follow-up keeps its question's number; an added question (a quiz's adaptive follow-up) shows the new total in its prefix (`Question 7/11 · …`). Any other question starts with what it belongs to: `Mechanism · question · …`, `Prediction · …`.
- **Content before the dialog.** While a question dialog is open the learner may see only the dialog, so text written earlier in the same turn can be hidden. A turn that teaches (an explanation, a table, video links, lab output, a part marker, the answer to a typed "why…?") ends without a dialog, on one line saying what's next, such as "Next: a question on this. Say *next* when you've read it, or ask anything." The question comes in the next turn, which only asks it: everything it needs, counts and positions included, is in the question text and the option previews. A verdict is content too: it either opens a teaching turn (no dialog), or comes first in the next question's text, before the position: `**Incorrect.** <short why> · Question 3/10 · …`. Never teaching content and a dialog in the same turn. The plain-text fallback has no dialog, so this doesn't apply to it.
- Record, per question, the data shown, the options, the pick (or the typed text) and the verdict word (Correct / Partly correct / Incorrect): it's the evidence a check, quiz score or done-check counts. Synthetic or lesson data is recorded in full; a linked project's code or output only as its `<slug>:path@sha` citation and a paraphrase, never pasted.
- Without AskUserQuestion (headless, or denied), ask in plain text with the data above the question and the options listed.
Flashcards are questions too: each card is one AskUserQuestion call as above. The first card's text carries the count this review will ask and how many due cards wait for a later one, `Review · 12 cards (3 wait) · Card 1/12 · `, and later ones `Card n/N · `. The card's answer, condensed, is one option; the distractors are near misses that make the learner recall rather than recognise (the same idea swapped, a near-miss formula, the confusion the card exists to fix), and each is clearly wrong against the card's answer, never a defensible rewording of it. A typed Other is judged on its meaning as the answer, unless it asks to stop or skip the review: then the review ends there and that card is left as it was. The verdict is **Correct.** or **Incorrect.** only (a card has one part) and moves the card's box. Record each card's options, pick and verdict in the review's log entry. Without AskUserQuestion (headless, or denied), cards stay plain text without options, unlike other questions: the learner answers in their own words.
Two kinds stay in plain text: hints (practice's pointing question must not hand over the approach as an option), and open questions that ask for the learner's account (reflect's talk-through questions).
Two kinds that sound alike follow different rules. A **comprehension check** (build mode's "is this clear?": a question on a concept, with a right option and distractors) is a question like any other above: verdict, record. A **feedback question** asks about the materials, not the concept (practice's handover question "are these instructions clear?", on the exercise's instructions and setup): it has no right answer, so it uses the format above, its prefix (`Practice · feedback · `) and **Content before the dialog**, but gets no verdict and is never recorded as evidence.
**Examples.** Every question and explanation shows all the data it relies on, right there:
- Never refer back to an earlier table ("the parcels from our table") without showing it again.
- To build on an example, re-show it whole with the new columns added; never a partial or derived table that drops a column the question depends on.
- A concept that doesn't need the old example gets a fresh one. Each lesson opens with its own self-contained example; it may reuse a running example, shown again in full.
- Keep examples to 6 rows or fewer, so they fit in a preview.
## Registry
`${LEARNING_WORKFLOW_HOME:-~/.config/learning-workflow}/spaces.json` (the same root the learn-mode state uses). Each entry in `spaces` is a subject:
```json
{
"repo": "/home/me/Learning",
"spaces": [
{
"slug": "rust",
"path": "/home/me/Learning/rust",
"created": "2026-11-04",
"projects": [
{"slug": "billing-service", "path": "/home/me/work/billing-service",
"remote": "git@github.com:acme/billing-service.git", "branch": "main", "sensitivity": "work"},
{"slug": "ray-tracer", "path": "/home/me/code/ray-tracer",
"remote": null, "branch": "main", "sensitivity": "personal"}
]
}
]
}
```
Create the file if missing; add or extend entries; never remove anything without asking. An entry whose folder is its own git root (`git -C <path> rev-parse --show-toplevel` prints `<path>` itself) is a **standalone** v0.1.0 repo, wherever it sits, even inside `repo`'s directory: it still resolves and works, and `/learn:init` offers to migrate it. A subject of the learning repo has `repo` as its git top level.
**Resolving the subject (every /learn skill does this):**
1. A `LEARNING.md` in the current directory or an ancestor: its folder is the subject.
2. Else every subject whose `projects[].path` contains the current directory. If one, use it; if several, ask.
3. Else the only registered subject.
4. Else ask which one. If none is registered, offer `/learn:init`.
Every path a skill writes (`curriculum/`, `plans/`, `builds/`, `lessons/`, `reflections/`, `flashcards/deck.md`, `PROGRESS.md`, `scratch/`) is relative to the resolved **subject folder**, and its data policy is the one in that folder's `LEARNING.md`. Commits go to the learning repo that contains it (`git -C <subject folder> …`), scoped by subject: `docs(<subject>): …`. Stage only that subject's paths (`git add -A -- <subject folder>`, plus `README.md` when the index changes), never `git add -A` on the whole repo, so another subject's uncommitted work never lands in this subject's commit. For a standalone v0.1.0 repo the subject folder is the repo root and the scope may be dropped.
From a project in build mode, the subject is fixed when learn mode starts: it is the folder of the plan named in the state file (`plan <subject folder>/plans/<plan>.md`). `/learn:build`'s wrap-up and `/learn:off` use that folder, never the project's directory.
The **current project** is the linked project whose path contains the current directory (compare whole path components, so `/x/app` doesn't match `/x/app2`), or, inside a git worktree, the project whose path is that repo's main worktree (the first entry of `git worktree list --porcelain`), or the one the user names. Skills that cite code use it.
## Finish
Report the learning repo path, the subject folder, the linked projects with their sensitivity, and the next step: `/learn:curriculum <plan, spec or topic>` to build the subject's first track. After a migration, also report the commits carried over and whether the standalone repo was kept. If the learning repo has no remote, mention once that `/learn:init remote` adds a private one to sync across machines.
Pliki w paczce (13)
- SKILL.md 32 KB
- toolchains.md 5 KB
- templates/repo/CLAUDE.md 3 KB
- templates/repo/README.md 1 KB
- templates/repo/gitignore 1 KB
- templates/repo/tools/guard.sh 2 KB
- templates/repo/tools/hooks/pre-commit 1 KB
- templates/subject/LEARNING.md 2 KB
- templates/subject/PROGRESS.md 1 KB
- templates/subject/deck.md 1 KB
- templates/v0.1.0/CLAUDE.earlier.md 1 KB
- templates/v0.1.0/CLAUDE.md 1 KB
- templates/v0.1.0/gitignore 1 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · rafagomes/learning-workflow | 100 | MIT |
| CodaColaLight/nightmill | 100 | Apache-2.0 |
| userKael/rastro | 100 | MIT |
| elalfner/relevo | 100 | MIT |
| abatyuk/okf | 100 | MIT |
| duronext/jig | 100 | MIT |
| sh5623/e2e-rail | 100 | MIT |
| Calvin-LLC/skills | 100 | MIT |
| arxdsilva/ai-loops | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 1119fbc71d14 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100plan
Łączy plan projektu z planem nauki: dzieli zakres na kroki i wskazuje pojęcia nowe dla ucznia oraz pytania sprawdzające po każdym kroku. - 90new-subject
Zakłada nowy przedmiot do nauki z tutorem: z tematu z mapą zagadnień albo z planu zajęć, po akceptacji ucznia. - 100learn
Prowadzi naukę wybranego tematu z folderu learning: wznawia wątek, przypomina wcześniejsze treści i trzyma ustaloną kolejność. - 95orbitant-new-learning
Podpowiada, czego się uczyć dalej, proponuje projekty na lukę kompetencyjną i dopisuje tematy do listy nauki. - 100start-learn
Kieruje cel nauki do pracy z istniejącym kodem albo do przestrzeni nauki od zera, gdy metoda nauki nie została jeszcze wybrana. - 100curriculum
Buduje ścieżkę nauki z planu projektu lub opisu: fazy, tematy, wymagania wstępne i kryteria gotowości zapisane w pliku curriculum.