If you've ever spent two hours after class trying to organize your notes, this is for you. Claude Code can take raw lecture transcripts or slide text and produce a structured concept table in under three minutes — no reformatting, no manual skimming required. I tested this on my Mac Mini running n8n 2.8.4, and the workflow is solid enough that I've baked it into my daily study routine.
The Problem: Note Organization is the Real Bottleneck
Understanding the lecture isn't the hard part. Writing it all back down in a usable format is. The typical post-lecture workflow looks like this: read through your notes, highlight the important bits, read them again, then re-type everything into some kind of structured format. That's three separate passes over the same material, and it kills an evening.
The underlying issue is that traditional note-taking tools don't understand your content — they just store it. You still have to do all the cognitive work of extraction and organization.
What I tried first was copying everything into Notion and using templates — but templates don't extract meaning, they just impose structure on chaos. You're still manually deciding what goes where.
The Fix: One Prompt, One Paste
Claude Code reads the entire text as a single context window. It does the highlighting, the re-reading, and the re-typing simultaneously. Think of it like a reference librarian who skims a whole book and hands you an index card — in seconds.
The core command is dead simple:
claude "From the lecture text below, extract key concepts, definitions, and examples into a table. Columns: [Concept | One-line Definition | Representative Example]"
Paste your transcript or slide text right after that, and you're done. The output is a clean markdown table.
Here's what the interaction looks like end-to-end:
claude "From the lecture text below, extract key concepts, definitions, and examples into a table. Columns: [Concept | One-line Definition | Representative Example]
--- BEGIN LECTURE TEXT ---
Today we're going to talk about backpropagation. So backpropagation is basically...
[your raw transcript here]
--- END LECTURE TEXT ---"
Expected output:
| Concept | One-line Definition | Representative Example |
|--------------------|----------------------------------------------------|---------------------------------|
| Backpropagation | Algorithm for computing gradients in neural nets | Training a 3-layer MLP |
| Learning Rate | Step size during gradient descent | lr=0.001 in Adam optimizer |
| Vanishing Gradient | Gradients shrink to near-zero in deep networks | Sigmoid activation in 10 layers |
That's it. Three minutes including paste time.
Slides vs. Transcripts: Tune the Prompt for the Input Type
Here's the gotcha I hit early on: slide text and lecture transcripts need slightly different prompts because they're structured differently.
Slides are hierarchical— bullet points, headings, and sub-items form a clear conceptual tree. Transcripts arestream-of-consciousness — the instructor talks in circles, repeats themselves, and drops in tangents. Same concept, completely different shape.
Think of it as the difference between a recipe book (slides) and a cooking YouTube video's auto-captions (transcript). The recipe book has clean structure you want to preserve. The auto-captions have noise you want to strip.
| Input Type | Characteristics | Prompt Addition |
|---|---|---|
| Slide text | Hierarchical, bullet-heavy, concise | "Preserve the parent-child structure of headings" |
| Transcript | Linear, repetitive, conversational filler | "Exclude filler phrases and repetition; extract core ideas only" |
| Mixed (slides + notes) | Both issues at once | Use both additions |
For slides:
claude "From the slide text below, build a concept table. Preserve the hierarchy of headings. Columns: [Concept | Definition | Example]
[slide text here]"
For transcripts:
claude "From the transcript below, build a concept table. Skip filler phrases, repeated explanations, and off-topic tangents. Extract only the core concepts. Columns: [Concept | Definition | Example]
[transcript here]"
The density difference between these two is noticeable. The slide prompt produces tight, precise rows. The transcript prompt filters aggressively and gives you the same result from much noisier input.
Breaking the Table into Atomic Notes for Obsidian
A single large table is useful for a quick scan, but it's annoying for long-term use — every time you want one concept, you open the whole file. The fix is atomic notes: one concept per file.
This is a core principle from the Zettelkasten method. Each note is self-contained and linkable. When your vault has 50 atomic concept files from five lectures, you can build Maps of Content (MOC) and cross-link related ideas across courses.
The command to split the table is one line:
claude "Take the concept table above and split each row into a separate markdown file. Filename = concept-name.md, first line = definition, second line = example."
What you get back is a set of files like:
backpropagation.md
learning-rate.md
vanishing-gradient.md
Each file looks like:
Algorithm for computing gradients in a neural network by propagating error backward from the output layer.
Training a 3-layer MLP with cross-entropy loss and Adam optimizer.
Drag those into your Obsidian vault and you're immediately ready to link them. From backpropagation.md, you can reference [[vanishing-gradient]] and [[learning-rate]] with Obsidian's wiki-link syntax. Your lecture just became a connected knowledge graph.
Section 4: Building a Review System on Top
The table and the atomic notes are only useful if you actually revisit them. Based on Ebbinghaus's forgetting curve, a single review within 24 hours of learning raises retention by over 60%. The problem is that most people make notes and never look at them again.
What worked for me was turning the concept table into a quiz. One more prompt:
claude "Using the concept table above, generate 5 fill-in-the-blank quiz questions. Format: the concept name is the blank, the definition and example are the clues."
Output looks like:
Q1: ________ is an algorithm that propagates error backward through a network to compute gradients.
Example: Used when training an MLP with cross-entropy loss.
Q2: A ________ controls how large each update step is during gradient descent.
Example: Setting it to 0.001 in Adam.
Run this the evening after your lecture. The next morning, before the next class, spend five minutes on those five questions. That's the full loop: extract → atomize → review.
Variations and Gotchas
Long transcripts (90+ minutes): Claude Code handles large contexts well, but extremely long transcripts can produce bloated tables. Split the transcript at natural section breaks (topic shifts, Q&A segments) and run the prompt on each chunk separately. Then merge the tables.
Non-English lectures: The prompt language and the lecture language don't have to match. You can prompt in English and paste a Spanish or Korean transcript. Claude Code handles this without any extra configuration.
PDF slide exports: If your slides are PDF, you need text first. On Mac, use pdftotext from Homebrew:
brew install poppler
pdftotext lecture_slides.pdf lecture_slides.txt
Then paste lecture_slides.txt into the prompt. Takes 30 seconds.
Auto-generated captions from Zoom/Google Meet: These often include speaker labels (Speaker 1: ...). Add "Ignore speaker labels" to your transcript prompt to prevent them from bleeding into the concept column.
Environment differences:
| Environment | Notes |
|---|---|
| Mac (Apple Silicon) | No issues. Native Claude Code CLI works directly. |
| Linux | Same. Install via npm install -g @anthropic-ai/claude-code. |
| Docker | Mount your text files as a volume; pipe output to a host directory. |
Closing
The real bottleneck in lecture review isn't comprehension — it's the time cost of re-organizing what you already understood. Claude Code removes that bottleneck with a single paste. Whether you're working from slides or a raw Zoom transcript, the pipeline is the same: extract → atomize → quiz.
Next step worth exploring: automate the quiz delivery with n8n. Set a webhook to fire 20 hours after you create the concept table, and have it push the quiz questions to your phone via a notification. The review happens without you having to remember to do it.
🐦 Faster updates on X: @baegseungh7061
📚 More in this series: Code Intro
💌 Subscribe: Follow on X or grab the RSS
댓글
댓글 쓰기