Teach From Paper logo

Teach From Paper

CommunityPopular
pedrohcgs
teach-from-paper

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".

Overview

Publisherpedrohcgs
Repositoryclaude-code-my-workflow
Skill nameteach-from-paper
Stars
1.6K
Forks
3.1K
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by pedrohcgs on GitHub. Read the source before you install it.

Installation

Install the Teach From Paper AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/pedrohcgs/claude-code-my-workflow/tree/main/.claude/skills/teach-from-paper
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
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
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Teach From Paper in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Teach From Paper on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Teach From Paper is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

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.
FormatHow to read it
.tex, .qmd, .md, .txtRead directly with the Read tool.
.pdfTMP=$(mktemp -d)/paper.txt && pdftotext "$0" "$TMP" (poppler-utils), then Read/Grep "$TMP".

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:

markdown
## 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

  1. 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.
  2. 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).
  3. Map the paper's notation to something teachable; flag any symbol clash a student would trip on.
  4. 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

  1. Write 4-6 discussion questions graded by depth: comprehension → application → critique ("where would this identification fail?"). Pitch to the level.
  2. 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 quality_reports/teach_from_paper_[sanitized-title].md:

markdown
# 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.

Frequently asked questions

What does the Teach From Paper AI skill do?

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".

Why use Teach From Paper on TypingMind?

Because you install it once and use it with any model. Teach From Paper is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Teach From Paper in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/pedrohcgs/claude-code-my-workflow/tree/main/.claude/skills/teach-from-paper. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Teach From Paper?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Teach From Paper?

As many as you like. As long as a model supports skills, you can use Teach From Paper with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Teach From Paper AI skill free?

Yes. It is published on GitHub by pedrohcgs under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇