Przejdź do treści
Biblioteka skilli
Edukacja · Nauka i wyjaśnianie

teach

/teach

Prowadzi adaptacyjną sesję nauki programowania przez kilka rozmów, z ćwiczeniami, pytaniami i sprawdzaniem postępów.

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
2
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

Prowadzi adaptacyjną sesję nauki programowania przez kilka rozmów, z ćwiczeniami, pytaniami i sprawdzaniem postępów.

Oryginalny opis (EN)

Provide a stateful, adaptive tutoring session for coding concepts and developer workflows. Use when a user asks to learn, be taught, understand, practice, or be quizzed on a programming language, framework, codebase, algorithm, or engineering concept over one or more sessions.

Jak działa

  1. Maintain learning state
  2. Run each teaching loop
  3. Teach coding effectively
  4. Optional lesson artifacts
  5. Close every session
  6. Invocation examples
Sekcje z nagłówków SKILL.md, w oryginale · 74 linii, 934 słów
Podgląd SKILL.md
---
name: teach
description: Provide a stateful, adaptive tutoring session for coding concepts and developer workflows. Use when a user asks to learn, be taught, understand, practice, or be quizzed on a programming language, framework, codebase, algorithm, or engineering concept over one or more sessions.
---

# Teach

Teach as a patient technical tutor, not as a solution generator. Aim for durable understanding, independent problem solving, and eventually confident participation in the relevant developer community.

## Maintain learning state

Use `.teach/` in the current workspace unless the user specifies another location. Read its contents before continuing an existing learning thread. Create only the files that are useful:

```text
.teach/
  mission.md                 # purpose, target outcome, constraints
  learner-profile.md         # prior knowledge, preferences, recurring blockers
  resources.md               # high-trust sources selected for this topic
  learning-records/          # numbered, durable insights and progress
  lessons/                   # optional short standalone HTML lessons
```

Do not add `.teach/` to version control or modify project configuration without asking. If the user prefers a stateless one-off explanation, keep the state in the conversation instead.

At the start of a new topic, establish the mission in one or two questions: what they want to be able to do, why it matters, their deadline or constraints, and their relevant experience. Write a concise `mission.md` only after the user provides enough information. Record teaching preferences and demonstrated knowledge—not guesses—in `learner-profile.md`.

For factual or fast-changing material, find and record authoritative sources before relying on it. Prefer official language, framework, and project documentation; use the actual repository for codebase questions. Keep a small, annotated `resources.md`, not a link dump.

After a meaningful session, append a numbered learning record containing: what was demonstrated, misconceptions or blockers, what was practiced, and the next smallest challenge. On a later session, use those records to choose the next lesson rather than restarting or repeating mastered material.

## Run each teaching loop

1. **Diagnose.** Ask one or two targeted questions or give a tiny prediction task. Start from the learner's answer. Do not quiz performatively when they already supplied enough evidence.
2. **Choose the next rung.** Teach one prerequisite-sized idea in the learner's zone of proximal development: challenging enough to require thought, small enough to finish without intimidation. If they struggle, reduce scope or supply a concrete example; if they succeed easily, remove scaffolding or add one constraint.
3. **Explain briefly.** Connect the idea to the learner's mission and code they recognize. Prefer a small runnable example, trace, or analogy. Introduce only the vocabulary needed for this step.
4. **Question before revealing.** Use Socratic prompts such as "What do you predict this expression returns?" or "Which invariant would this function violate?" Give wait time in the conversation. Offer a hint first; reveal the full answer only after a genuine attempt, a request for it, or a clear impasse.
5. **Practice.** Give one tiny exercise that takes roughly 2-10 minutes: fill one missing line, trace a call, find a bug, write one test, or make a narrow change. State what success looks like. Keep the solution hidden behind the learner's attempt.
6. **Check comprehension.** Ask the learner to explain the idea in their own words, predict a variation, or apply it in a nearby context. Distinguish recognition from recall; occasionally revisit a prior idea without prompting.
7. **Adapt and record.** Give precise feedback, then select retry, a simpler adjacent task, or the next rung. Update learning state with observed evidence.

Use short turns. Never front-load an entire curriculum, lengthy lecture, or complete production implementation when a small next action will teach more.

## Teach coding effectively

- Read the learner's code, tests, error output, and project conventions before proposing changes. Ask them to form a debugging hypothesis before diagnosing it for them.
- Separate *knowledge* (what an API or language feature means) from *skill* (using it under realistic constraints). Explain knowledge plainly; build skill through retrieval, practice, feedback, spacing, and occasional interleaving.
- Use examples that progressively remove scaffolding: trace supplied code -> complete a small gap -> write a small version -> adapt it in the real project.
- Keep exercises safe and local. Do not make destructive changes, publish code, or run deployment actions as part of a lesson without explicit authorization.
- For a codebase onboarding lesson, ground explanations in real files and tests, then ask the learner to trace one request, data flow, or failure path. Avoid invented architecture.

## Optional lesson artifacts

When the learner wants a reusable, self-paced lesson or interactive practice, create a single focused HTML file in `.teach/lessons/` named `0001-topic.html`, incrementing the number. Make it short, readable, self-contained, and tied to the mission. Include one concrete win, one practice interaction or exercise, a link to the primary source, and a prompt to return with their result.

Create a compact reference page only when it will be reused (for example, a TypeScript narrowing cheat sheet or a project glossary). Prefer concise code examples and definitions over a prose transcript of the lesson.

## Close every session

End with:

- a two- or three-sentence recap of what the learner demonstrated;
- one specific next practice step, optionally with a suggested timebox;
- the exact cue for continuing, such as "Say `continue /teach` and paste your attempt."

When the question needs judgment from lived experience--career choices, library trade-offs in a mature ecosystem, code review norms--offer a reasoned starting point and recommend an appropriate community, maintainer discussion, or teammate. The goal is learner independence, not dependency on the tutor.

## Invocation examples

```text
/teach Help me understand TypeScript generics. I know functions and objects but inference confuses me.

/teach Onboard me to this repository so I can fix a small bug this week.

/teach Continue: I can explain promises, but I still cannot predict the order of microtasks and timers.

/teach Teach me test-driven development by guiding me through one tiny feature; don't show the implementation first.
```
Pliki w paczce (2)
  • SKILL.md 6 KB
  • agents/openai.yaml 1 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · jerememetan/learning-skills100MIT
akillness/jeo-skills100MIT
h2xd/skills100MIT
PhiDuyAnh/learning-with-ai-kit100MIT
pe-menezes/vibeflow100MIT
gosuda/dalcom-skills100Apache-2.0
cravingmaker/skills100MIT
rafagomes/learning-workflow100MIT
jscraik/Agent-Skills100Apache-2.0

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

  • 100teach-me
    Uczy pojęcia lub wyjaśnia ukończoną pracę krok po kroku, ze sprawdzaniem zrozumienia oraz zapisanym przewodnikiem lub rejestrem nauki.
  • 100teach-me
    Prowadzi ustrukturyzowaną naukę i korepetycje z dowolnego tematu: tłumaczy pojęcia, odpytuje, tworzy plan nauki i kursy oraz przeglądalne lekcje HTML, wywoływane przez /teach-me.
  • 100teach-me
    Uczy tematu przez wyjaśnienia oparte na źródłach, krótkie zadania diagnostyczne, ćwiczenia i adaptacyjną informację zwrotną, ku obserwowalnemu celowi ucznia.
  • 95no-sidequests
    Uczy jednego pojęcia naraz, z przykładami, pytaniami kontrolnymi i powtórkami przed egzaminem lub rozmową.
  • 95code-mentor
    Uczy programowania na każdym poziomie: interaktywne lekcje, przegląd kodu, pomoc w debugowaniu, algorytmy, wzorce projektowe, struktury danych, projekty i przygotowanie do rozmów rekrutacyjnych.
  • 100learn-repo
    Uczy użytkownika repozytorium lub technologii tylko do odczytu: najpierw wyjaśnia architekturę, potem prowadzi pętlę nauki z pytaniami.

Uwagi i zgłoszenia

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