teach-from-paper skill
Turn a research paper into teaching materials — a lecture outline, the 3-5 results worth presenting (with intuition), a slide skeleton ready for `/create-lecture`, discussion questions, and a problem-set brief. Reads the paper end-to-end and pitches to a stated audience level. Use when user says "turn this paper into a lecture", "teach from this paper", "build slides from this PDF", "make teaching materials from X", "I'm presenting this paper to my class".
Is the teach-from-paper skill safe?
Clean: nothing in its files matched our rules. We read 1 file in the folder on 2026-09-28.
No findings.
Install the teach-from-paper skill
A skill is a folder. Copy it into your agent's skills folder and the agent loads it when the task matches its description.
git clone --depth 1 https://github.com/pedrohcgs/claude-code-my-workflow.git /tmp/claude-code-my-workflow mkdir -p ~/.claude/skills cp -r /tmp/claude-code-my-workflow/.claude/skills/teach-from-paper ~/.claude/skills/teach-from-paper
In the Claude apps, zip the folder and upload it from the Skills settings. The folder on GitHub
The instructions your agent would load
SKILL.md as published, without the frontmatter. Read it on GitHub
Teach From Paper
Convert one research paper into a ready-to-build teaching package: a lecture outline, a shortlist of teachable results with the intuition spelled out, a slide skeleton, discussion questions, and an exercise brief. The deliverable is an outline and a brief — not a finished deck; the slide skeleton is shaped to hand straight to /create-lecture, and the exercise brief to /scaffold-exercises.
When to use
- You have a paper (PDF, .tex, .md) and a slot to teach it — a lecture, a reading group, a job-market practice talk.
- You want the teachable core extracted and pitched to a level, not a generic summary.
- You're prepping the plan for a deck and want /create-lecture to do the drafting.
Not for: literature surveys across many papers (use /lit-review); refereeing the paper's correctness (use /review-paper); drafting the actual Beamer slides (use /create-lecture).
Inputs
- $0 — path to the paper.
If extraction fails or the tool is missing, ask the user for a plain-text version and stop. A scanned or partly scanned PDF extracts with exit 0 and blank pages, so also compare pdfinfo "$0" | grep Pages with the pages that returned text (awk 'BEGIN{RS="\f"} NF{n++} END{print n+0}' "$TMP"); read any blank pages directly with Read, or ask for a text version, and if you go on without them, say which pages were not read. When you are done, delete the extracted copy (rm -rf "$(dirname "$TMP")"): it is a plaintext copy of the document. The full paper goes in the context window (1M) — read it end-to-end before extracting; do not skim the abstract and guess.
Phases
Phase 0: Read the Paper + Set Audience Level (Pre-Flight Report)
Read the paper start to finish. Then resolve the audience level and time budget — from --level / --minutes if given, otherwise ask once. Echo a Pre-Flight Report before extracting:
## Pre-Flight Report
**Paper:** [title, authors, year]
**One-line thesis:** [the paper's central claim in your words]
**Audience level:** undergrad | phd | seminar (drives notation depth + which proofs survive)
**Time budget:** N minutes (~N/2 slides)
**Prerequisites assumed:** [concepts students must already have]
**Running example candidate:** [the paper's application that can thread the lecture]Get a nod on level + thesis, then proceed. Level governs everything downstream: undergrad keeps intuition and drops proofs; phd keeps the identifying assumptions and one key derivation; seminar foregrounds the contribution-vs-literature framing.
Phase 1: Extract the Teachable Core + Intuition
- Identify the paper's 3-5 results worth presenting — not every proposition, the ones a student should leave remembering. Prefer the headline result, the identifying assumption that makes it credible, and one surprise or limitation.
- For each, capture: the formal statement (trimmed to the audience level), the intuition (why it's true in one breath, no algebra), and the failure mode (when it breaks).
- Map the paper's notation to something teachable; flag any symbol clash a student would trip on.
- Separate method (how they get the result) from takeaway (what we now believe) — students conflate these; the lecture must not.
Phase 2: Build the Lecture Outline + Slide Skeleton
Produce a motivation → setup → key result → method → takeaways arc, then a slide skeleton matching the time budget (~2 min/slide). Each skeleton entry is a title + one-line content note + figure/diagram placeholder — enough for /create-lecture to draft from, no prose. Honor the project's pedagogy invariants in shape: motivation before formalism, a worked example near each definition, a transition slide at each act break.
Phase 3: Discussion Questions + Exercise Brief
- Write 4-6 discussion questions graded by depth: comprehension → application → critique ("where would this identification fail?"). Pitch to the level.
- Write an exercise brief — 2-4 problems sketched (prompt + what skill it drills + expected-answer shape), NOT full solutions. This is the hand-off to /scaffold-exercises, which fleshes out problems, data, and answer keys. Skip if --no-exercises.
Output / Report format
Write to qualityreports/teachfrompaper[sanitized-title].md:
# Teaching Package: [Paper Title]
**Audience:** [level] · **Budget:** [N min] · **Date:** [YYYY-MM-DD]
## 1. Lecture Outline
Motivation → Setup → Key Result → Method → Takeaways (one line each)
## 2. Results Worth Presenting
### R1 — [name]
- **Statement:** … · **Intuition:** … · **Breaks when:** …
[R2..R5]
## 3. Slide Skeleton (→ /create-lecture)
| # | Title | Content note | Figure/diagram |
## 4. Discussion Questions
1. [comprehension] … 5. [critique] …
## 5. Exercise Brief (→ /scaffold-exercises)
- **E1:** [prompt] — drills [skill] — answer shape: [form]Exit behavior
- Present the package in chat and confirm the file path written.
- Name the two hand-offs explicitly: "Slide skeleton ready — run /create-lecture [Topic]. Exercise brief ready — run /scaffold-exercises."
- If the audience level was never confirmed, do not ship — a deck pitched at the wrong level is wasted work. Halt and ask.
Flags
- --level — undergrad | phd | seminar. Sets notation depth, which proofs survive, and question difficulty. Asked interactively if omitted.
- --minutes — target lecture length; the slide count is roughly --minutes/2.
- --no-exercises — skip Phase 3's exercise brief (keep discussion questions).
Cross-references
- /create-lecture — consumes the Phase 2 slide skeleton to draft the actual Beamer deck. See .claude/skills/create-lecture/SKILL.md.
- /review-paper — referee the paper's correctness before teaching it if you're unsure the result holds. See .claude/skills/review-paper/SKILL.md.
- /lit-review — for situating the paper among many, rather than teaching one deeply. See .claude/skills/lit-review/SKILL.md.
- The exercise brief (written in Phase 3; section 5 of the output) is the input contract for /scaffold-exercises, which fleshes out problem sets; this skill stops at the brief.
What this skill does NOT do
- Does not draft finished slides — that's /create-lecture. The slide skeleton is an outline, not Beamer.
- Does not write full problem-set solutions — the exercise brief is a sketch for /scaffold-exercises.
- Does not verify the paper is correct — pair with /review-paper if the result's validity is in doubt.
- Does not read multiple papers or survey a field — one paper in, one teaching package out.
More skills from pedrohcgs/claude-code-my-workflow
- Aadjudicate-reviewTurn an incoming set of findings — from an AI reviewer, a referee report, a code review, a linter, or a second model — into verified fixes, without letting a confident misread damage correct work. Every finding is a CANDIDATE until checked against the actual source. Use whenever you receive review comments, audit findings, or a critique you did not write yourself, especially when the reviewer is a model or when the volume is too large to check by feel.
- Aaudit-reproducibilityEnforce the replication-protocol.md rule by cross-checking numeric claims in a manuscript against the actual R / Stata / Python outputs. Report PASS/FAIL per claim against tolerance thresholds. Use before submission and before releasing a replication package.
- Ablast-radiusBefore and after changing anything shared — a function's return value, a signature, a schema, a label set, a config default, a constant, a file format — find every consumer and actually run them. Catches the change that looks purely additive but silently breaks a contract in a file you never opened. Use when editing shared code, adding a field/column/return element, renaming, changing units or defaults, or touching a pipeline that produces reported numbers.
- Acapture-environmentSnapshot the computational environment for a replication package — detects the analysis stack (R / Stata / Python) and emits the right lockfiles (renv.lock + sessionInfo.txt, requirements.txt / environment.yml / uv.lock, Stata version + ado package list), records seeds and RNG kind, optionally writes a pinning Dockerfile, and produces a paste-ready "Computational requirements" block. Use when user says "capture the environment", "snapshot my dependencies", "pin the versions", "make a renv.lock / requirements.txt", "make this byte-reproducible", or before releasing a replication package to openICPSR / the AEA Data Editor.
- AchallengeStress-test a finding against the choices you did not make. Enumerates the discrete forks a competent analyst could have taken (measure definition, sample filter, control set, clustering level, weighting, functional form), runs the specification grid, and reports the distribution rather than a point estimate — then attacks the identifying assumption with named, computable sensitivity statistics. Use when the user says "is this robust", "challenge this result", "specification curve", "multiverse", "how sensitive is this", "what if I'd used a different measure", "stress-test my estimate", or before a result becomes a headline claim. NOT a reviewer of prose or code — it challenges the CLAIM.
- AcheckpointSave a structured state snapshot before stopping or handing off. Captures the active plan, recent decisions, file pointers (with line numbers), open questions, and the next 1–3 actions into a checkpoint file under `quality_reports/checkpoints/`. Optionally proposes `[LEARN]` entries to add to MEMORY.md. Use when user says "checkpoint", "save state", "snapshot before I stop", "where am I", "wrap up the session for handoff", or before a long break / model switch / collaborator handoff. Companion to (NOT replacement for) the narrative session-log workflow.
- Acoauthor-briefGenerate a co-author / collaborator handoff brief for a multi-author, multi-machine project — summarizing what changed since the last brief (git delta), the current state of each artifact (manuscript, analysis, slides), open questions, how to reproduce locally, and any restricted-data access steps. Use when user says "coauthor brief", "handoff brief", "bring my coauthor up to speed", "what changed since last week", "onboard a collaborator", "write a handoff for [name]", or before sending a co-author the repo. NOT a commit or a checkpoint — it is the cross-machine, cross-person summary `meta-governance.md` only partially covers.
- AcommitCommit the current work — runs the quality, consistency and passport gates, branches off main if needed, stages specific files, and writes a commit whose subject states what is now true. Pushes and opens a pull request only with --pr or when the user asks; never merges — a merge happens only when the user explicitly says to merge. Use ONLY on explicit commit intent — user says "commit", "let's commit this", "open a PR", or prefixes with `/commit`. Do NOT auto-invoke on vague end-of-task phrases ("we're done", "wrap up") — those require explicit confirmation first. Never force-pushes or skips hooks.
- Acompile-latexCompile a Beamer LaTeX slide deck with XeLaTeX (3 passes + bibtex). Use when user says "compile", "build the slides", "rebuild the PDF", "run latex", "render the tex", or asks why a `.tex` file isn't producing a PDF. Operates on `Slides/*.tex`.
- Acompress-sessionDistill the current conversation into a structured note (decisions made, open questions, file pointers with line numbers, next 1–3 actions) and save to `quality_reports/session_logs/` before auto-compression. Differs from `/checkpoint` (explicit stop-point snapshot) and from auto-compaction (which truncates rather than distills). Use when context is approaching auto-compact threshold, when a long pipeline has accumulated many decisions, or when the user says "compress", "distil this session", "before we hit auto-compact", "structured handoff before context resets".
- Acontext-statusShow current context status and session health. Use to check how much context has been used, whether auto-compact is approaching, and what state will be preserved.
- Acreate-lectureCreate a new Beamer lecture `.tex` from source papers and materials, with notation consistency checks and the project's preamble wired in. Use when user says "create a lecture on X", "new lecture from these papers", "start a deck on topic Y", "scaffold a new Beamer file", "build me a lecture from these PDFs". Scaffolds the full deck — NOT for compiling existing `.tex` (use `/compile-latex`).