teaching-pipeline

Files (6)

• SKILL.md
• gate_runner_agent.md · agents/
• iteration_coach_agent.md · agents/
• passport_keeper_agent.md · agents/
• pipeline_orchestrator_agent.md · agents/
• pipeline_state_machine.md · references/

SKILL.md (first lines)

# Teaching Pipeline — Course Lifecycle Orchestrator

Orchestrates the whole teaching lifecycle — design, build, assess, deliver, reflect,
improve — by dispatching the six sibling skills in backward-design order over a single
Course Passport (`shared/course_passport_schema.md`). The professor brings the
discipline, the students, and every decision; this skill brings sequence, gates, and
memory across the semester and across terms.

> **Prime rule:** unlike a paper pipeline, teaching is *cyclic and calendar-bound*.
> Stage 4 is a loop, not a step, and Stage 6 feeds Stage 1 of the next term. The
> passport plus today's position in the academic calendar — never the chat history —
> determines what happens next.

## Quick Start

```
I'm teaching a new course on machine learning next semester — run the whole pipeline
新学期要开一门《数据结构》，帮我把整门课准备出来
I already have a syllabus from last year — pick it up from there
It's week 6, what's next for my course?
课程现在什么状态？下一步做什么？
Term just ended, here are my student evals — close out the semester
```

## Modes

| Mode | Trigger intent | What it does |
|------|---------------|--------------|
| `full` | "Teach/prepare a whole course", new course from scratch | Stage 0 onward: intake → passport → all stages in order, every gate, every checkpoint |
| `mid-entry` | Professor arrives with existing materials or mid-process ("I already have a syllabus", "it's week 9") | Detect/ask where they are, validate existing materials into the passport (via course-designer `align-check`, not re-derivation), enter at the matching stage per the routing table below |
| `status` | "What's next?", "course status", 下一步 | Read passport + calendar position; report current stage, gate states, pending confirmations, and the next concrete action. Read-only |
| `new-term` | "Teaching it again", new semester of an existing course | Stage 6 → Stage 1 re-entry: load `iteration_history` evidence + the redesign brief, dispatch course-designer `redesign` with the evidence attached |
| `dashboard` | "Show me my course", "course overview", 课程总览 | Run `python3 scripts/build_dashboard.py <passport>` → single-file `course_dashboard.html` next to the passport: gates (stored + live re-check), outcomes, assessment plan, week-by-week resources with clickable local artifact links, ledger, workload, iteration history. Regenerated at any checkpoint on request — it is a build product of the passport, never hand-edited |

**Mode dispatch rule:** a passport already on disk + a vague request → run `status`
first and propose the next action; never restart `full` on top of an existing passport.
Detect intent in any language.

## Stage Map

```
Stage 0  CONTEXT    — intake → initialize Course Passport            🧑 checkpoint
Stage 1  DESIGN     — course-designer (full | redesign)              🧑 checkpoint
Gate 1.5 ALIGNMENT  — alignment_gate_protocol; BLOCK → back to 1     ✓ machine + professor ack
Stage 2  BUILD      — lesson-builder week-batch, in batches the
                      professor sizes (just-in-time by default)      🧑 checkpoint per batch
Stage 3  ASSESS     — assessment-architect per assessment_plan
                      entry + integrity-check                        🧑 checkpoint per instrument
Gate 3.5 QUALITY    — quality_gate_protocol; BLOCK → back to 2/3     ✓ machine + professor ack
Stage 4  DELIVER    — weekly loop for the whole term:
                      just-in-time builds · student-mentor on demand
                      · midcourse feedback at week 4–6               🧑 checkpoint per cycle
Stage 5  REFLECT    — teaching-reflector eval-analysis +
                      evidence triangulation                         🧑 checkpoint
Stage 6  IMPROVE    — iteration record → passport iteration_history;
                      prioritized change list; offer re-entry:
                      next term → Stage 1 redesign with evidence     🧑 checkpoint
```

| Stage | Skill / mode dispatched | Artifacts | Checkpoint / gate |
|-------|------------------------|-----------|-------------------|
| 0 CONTEXT | (this skill) intake | `course_passport.yaml` initialized | 🧑 context confirmed |
| 1 DESIGN | `course-designer` `full` (or `redesign` in `new-term`) | passport design fields, `syllabus.md`, `design_rationale.md` | 🧑 per course-designer's internal checkpoints |
| 1.5 ALIGNMENT | gate_runner → `shared/alignment_gate_protocol.md` | `gates.alignment_gate` findings + status | ✓ machine checks + professor acknowledgment; BLOCK → Stage 1, max 3 rounds |
| 2 BUILD | `lesson-builder` `week-batch` | `lessons/W*` packages, schedule `artifact_refs` | 🧑 per batch |
| 3 ASSESS | `assessment-architect` (`exam`/`quiz`/`project-brief`/`rubric`… per `assessment_plan` type) + `integrity-check` | instruments + rubrics, `ai_resilience` set per assessment | 🧑 per instrument |
| 3.5 QUALITY | gate_runner → `shared/quality_gate_protocol.md` | `gates.quality_gate` findings + status | ✓ machine checks + professor acknowledgment; BLOCK → Stage 2/3, max 3 rounds |
| 4 DELIVER | weekly: `lesson-builder` `week-batch` (next week); `student-mentor` (on demand); `submission-auditor` `spec`/`audit`/`batch-audit` (on demand, when work comes in); `teaching-reflector` `midcourse` (week 4–6) | week materials, mentoring outputs, submission audit reports, midcourse report | 🧑 per weekly cycle; person-affecting outputs per Checkpoint Protocol hard rule |
| 5 REFLECT | `teaching-reflector` `eval-analysis` + triangulation with peer/artifact evidence | evaluation analysis report | 🧑 analysis confirmed |
| 6 IMPROVE | iteration_coach | `iteration_history` entry, prioritized change list, redesign brief | 🧑 record confirmed; offer `new-term` |

**Build-ahead depth (Stage 2):** the pipeline does **not** default to building all 16
weeks up front. At the Stage 2 entry checkpoint the professor chooses a batch depth —
first week only, first unit, through the first exam, or everything. Just-in-time per
week/unit is the recommended default: lessons built months ahead go stale against the
real classroom. The choice is recorded in the passport and drives the Stage 4 loop.

## Mid-Entry Routing

Mid-entry is first-class, not an exception. The orchestrator validates what exists into
the passport (Iron Rule 3) and enters at the earliest stage whose entry invariants are
unmet (`references/pipeline_state_machine.md`).

| "I have…" | Entry point |
|-----------|-------------|
| Nothing — new course, blank page | Stage 0 `full` (offer course-designer `socratic` if aims are vague) |
| An old syllabus / inherited course outline | Stage 0 intake → back-fill passport from the syllabus (confirmed, not assumed) → course-designer `align-check` to validate → Gate 1.5 → Stage 2 (or back to Stage 1 `redesign` if the gate fails) |
| A full confirmed design but no class materials | Validate passport (or build one from the design) → Gate 1.5 if `not_run` → Stage 2 |
| Materials built but no exams/rubrics | Validate → Stage 3 (Gate 1.5 must show `pass`; if `not_run`, run it first — it is cheap and catches what Stage 3 would inherit) |
| Mid-semester, week N, course already running | Validate passport + ask/confirm calendar position → enter the Stage 4 loop at week N; Gates run retroactively only if the professor wants the audit |
| Term just ended, student evals in hand | Validate → Stage 5 (eval-analysis) → Stage 6 |

## Stage 4 — The Weekly Delivery Loop

Stage 4 is the term itself. Each cycle answers **the Monday question**: *"Week N — what's
due?"*

```
each week N of the term:
  1. ORIENT   — passport + calendar: what's taught in W(N+lead), what assessments are
                due/upcoming, what's already built (artifact_refs)
  2. BUILD    — just-in-time window: lesson-builder week-batch for the next unbuilt
                week(s) within the professor's chosen lead time (default: next week)
  3. SUPPORT  — student-mentor on demand ONLY: feedback batches, a struggling student
                the professor brings up, emails, office-hours prep;
                submission-auditor when work comes in: spec confirmed at assignment
                release, audit/batch-audit at collection
  4. MIDCOURSE— at week 4–6 (once): offer teaching-reflector `midcourse` — early
                feedback while there is still time to act on it
  5. CHECK    — 🧑 weekly checkpoint: what shipped, what's pending, next Monday's picture
```

Rules of the loop:

- **Resumable by calendar.** "What week are we in?" is answered from the passport's
  stored term calendar + today's date; a fresh session lands in the right cycle without
  recap. If the calendar was never stored, ask once and store it (Iron Rule 5).
- **Struggling-student support is on-demand and NEVER auto-initiated.** The pipeline
  does not scan grades, attendance, or any data for struggling students — the professor

From YujxZJCN/teaching-skills, MIT.

More from YujxZJCN/teaching-skills