Przejdź do treści
Biblioteka skilli
Edukacja · Planowanie

learn-syllabus

/learn-syllabus

Zadaje kilka pytań diagnostycznych i pisze plan kursu z modułami, celami, wymaganiami wstępnymi, czasem i projektem końcowym.

Licencja
MIT
Ostatnia zmiana repozytorium
07.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 07.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Zadaje kilka pytań diagnostycznych i pisze plan kursu z modułami, celami, wymaganiami wstępnymi, czasem i projektem końcowym.

Wyzwalacze z opisu

I want to learn Xteach me Y from scratchmake me a course on Zbuild a study plan for this docwhere do I start with Rustturn this PDF into a syllabusI have two weeks to learn SQL

Argumenty

/learn-syllabus [topic, file path, or URL]
Oryginalny opis (EN)

Starts a personal course on any topic, document or skill. Asks 3-5 diagnostic questions to find the learner's real level, then writes learn/<topic>/syllabus.md with modules, verb-based learning objectives, prerequisites, time estimates and a capstone project, plus learner.md with the diagnosis. Use when the user says "I want to learn X", "teach me Y from scratch", "make me a course on Z", "build a study plan for this doc", "where do I start with Rust", "turn this PDF into a syllabus", or "I have two weeks to learn SQL".

Jak działa

  1. Steps
  2. Decision rules
  3. What NOT to do
Sekcje z nagłówków SKILL.md, w oryginale · 121 linii, 921 słów
Podgląd SKILL.md
---
name: learn-syllabus
description: >-
  Starts a personal course on any topic, document or skill. Asks 3-5 diagnostic
  questions to find the learner's real level, then writes learn/<topic>/syllabus.md
  with modules, verb-based learning objectives, prerequisites, time estimates and a
  capstone project, plus learner.md with the diagnosis. Use when the user says
  "I want to learn X", "teach me Y from scratch", "make me a course on Z",
  "build a study plan for this doc", "where do I start with Rust",
  "turn this PDF into a syllabus", or "I have two weeks to learn SQL".
argument-hint: "[topic, file path, or URL]"
---

# learn-syllabus

Builds the map before the journey. A syllabus written for "a beginner" in general
wastes the time of someone who already knows half of it, and loses someone who is
missing a prerequisite. So this skill measures first, with a few targeted diagnostic
questions, and only then writes a course sized to what this learner knows, how much
time they have, and what they want to be able to do at the end.

Everything is written to `learn/<topic-slug>/` in the current project. Other learn-*
skills read these files, so keep the formats below exactly.

## Steps

1. **Pin down the topic and the goal.** From the argument or conversation, get:
   - the topic (or source: a file path, a folder, pasted text). If the source is a
     codebase, stop and use **learn-repo** instead.
   - the goal: what the learner wants to *do* afterwards ("pass the AWS SAA exam",
     "read research papers on transformers", "ship a CLI in Go"). Ask once if missing.
   - time budget: hours per week and a deadline, if any. Default to 3 h/week.
   Make the slug: lowercase ASCII, words joined by `-`, at most 40 chars
   (`python-decorators`, `aws-saa-exam`). If `learn/<slug>/syllabus.md` already
   exists, read it and ask whether to revise or start a new course; never overwrite
   silently.

2. **If the source is a document**, read it fully first (Read for files; for long
   files read in parts). Note its section structure and the terms it assumes. The
   syllabus must follow what the document actually covers; mark anything you add
   from general knowledge as `(beyond the source)`.

3. **Run the diagnostic: 3-5 questions, one at a time.** Design them as a ladder:
   - Q1 checks a prerequisite ("What does a function return if it has no `return`?").
   - Q2-Q3 check the core idea at the level of using it.
   - Q4-Q5 check transfer: apply it to a new case, or spot the bug.
   Ask open questions, not multiple choice, so guessing does not inflate the level.
   Add "Say 'skip' if you have no idea; that is useful information." After each
   answer, do not teach or correct at length; note it and move on. If the first two
   answers are both blank or wrong, stop the ladder early: the learner is a beginner.

4. **Place the learner** on one of four levels and write the evidence:
   - `new`: missed the prerequisite question.
   - `beginner`: has prerequisites, cannot yet use the core idea.
   - `intermediate`: uses the core idea, fails transfer questions.
   - `advanced`: answers transfer questions; wants depth, edge cases, internals.
   Tell the learner the placement in one sentence with the reason, and let them
   override it.

5. **Design the modules.** 4-8 modules for most topics; each sized at 30-120 minutes
   of study. Order by dependency, not by the source's table of contents. Skip modules
   the diagnostic shows are already known, but list them under "Already solid" so
   the learner can see why. Every module gets:
   - 2-4 learning objectives that start with an observable verb (explain, compare,
     predict, write, debug, choose, derive, trace). Never "understand" or "know".
   - prerequisites as module ids (`M1, M3`) or `none`.
   - a time estimate in minutes.
   - one line on how mastery will be checked (what the quiz will ask them to do).

6. **Design the capstone.** One project that needs most modules, produces something
   the learner can show or use, and fits in 2-6 hours. Give it acceptance criteria
   (3-5 checkable bullets) and list the modules it draws on.

7. **Write `learn/<slug>/syllabus.md`** in exactly this shape (progress.py parses the
   `## M<n>.` headings):

   ```markdown
   # Syllabus: <Topic>

   Goal: <what the learner will be able to do>
   Level: <new|beginner|intermediate|advanced> (diagnosed <YYYY-MM-DD>)
   Time: <total hours> over <weeks> weeks at <h>/week
   Source: <file/URL or "general knowledge">

   ## M1. <Module title>
   - Objectives:
     - <Verb> <specific thing>
     - <Verb> <specific thing>
   - Prerequisites: none
   - Time: 45 min
   - Mastery check: <what they must do>

   ## M2. ...

   ## Capstone: <project name>
   <2-3 sentences>
   - Uses: M1, M3, M4
   - Done when:
     - [ ] <checkable criterion>

   ## Already solid
   - <topic> (diagnostic Q2 answered correctly)
   ```

8. **Write `learn/<slug>/learner.md`**: the goal, time budget, level, each diagnostic
   question with the learner's answer and your one-line verdict, and any preferences
   they mentioned (examples in Python, likes analogies, prefers short sessions).
   Other skills read this to set depth.

9. **Close the loop.** Show the module list as a short table (id, title, time), then
   offer the next step: "Start M1 now?" which runs **learn-lesson** on M1.

## Decision rules

- Fewer modules beat more. If two modules share all objectives, merge them.
- A module with no prerequisites should come early; a module needed by the capstone
  must not be optional.
- Deadline too short for the material: say so plainly, then cut scope to the goal
  (drop nice-to-have modules into an "Later" list) rather than squeezing times.
- Time estimates include practice, not just reading: roughly 1/3 explanation, 2/3
  retrieval and exercises.

## What NOT to do

- Do not skip the diagnostic because the learner said "I'm a beginner". Self-reports
  are often wrong in both directions. Two quick questions still beat zero.
- Do not ask all diagnostic questions in one message; one at a time, so each answer
  can shape the next.
- Do not write objectives with "understand", "learn about", "be familiar with".
- Do not invent facts about a provided document; cite its sections instead.
- Do not start teaching inside this skill. Diagnosis and planning only; teaching is
  learn-lesson's job.

Wersje

W bazie nie ma innych skilli o nazwie learn-syllabus.

Migawka bazy z 13.11.2026 · wersja paczki 631639c24fa2 (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

  • 90new-subject
    Zakłada nowy przedmiot do nauki z tutorem: z tematu z mapą zagadnień albo z planu zajęć, po akceptacji ucznia.
  • 100syllabus
    Buduje lub restrukturyzuje sylabus z listy tematów lub lektur: opis kursu, harmonogram tygodniowy, mierzalne cele, schemat oceniania z rubryką, polityki i listę prac dla create-lecture.
  • 100learning-plan
    Zamienia temat do nauki w uporządkowany plan z testem celu, wymaganiami wstępnymi, jednostkami z jednym głównym źródłem, powtórkami, projektem potwierdzającym umiejętność i tygodniowymi blokami czasu, a potem śledzi postępy.
  • 100course-syllabus-reading-list
    Tworzy uzupełniającą listę lektur na podstawie sylabusa kursu, z wyszukiwaniem w Consensus i wynikiem w formacie DOCX.
  • 100syllabus
    Buduje lub przebudowuje sylabus kursu: opis, wymagania wstępne, harmonogram tygodniowy, cele, zasady oceniania i polityki kursu.
  • 100create-course
    Buduje kurs lub przewodnik do samodzielnej nauki w HTML na dowolny temat techniczny, z programem, modułami, ćwiczeniami, egzaminami i niezależnymi recenzjami.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.