Summary of "What do you do after taking notes?"

Concise summary — main ideas

Taking notes is only the start. The crucial work is processing raw captures into reusable, composable “atomic notes” and then using those atomic notes to write, revise, and produce work.
Aim for a single trusted system (one place to store fleeting captures) that you process reliably and daily so nothing important is missed.
Atomic notes should be:
- Self-contained and written in your own words (digest, deconstruct, rebuild).
- Highly cohesive and loosely coupled (easy to reuse and compose without reading many other notes).
- Named and written so they will remind you later (human-readable filenames and body content that still makes sense months later).
A practical Zettelkasten-style organization is not a sprawling graph to browse but a linear/tree-like ordering of related notes: slot new atomic notes behind exactly one related note (the “up” parent) while using normal links for other relations.
Use spaced-repetition tooling creatively to manage a growing backlog of fleeting notes: snooze uncertain captures, surface urgent items, and make daily processing tractable.
The process divides into three system stages: Capture → Process → Write. This summary focuses on Process.

Detailed, actionable processing methodology (step-by-step)

Maintain a single trusted inbox
- Store fleeting captures only in one place (for example, an Obsidian vault) so you never miss a capture when processing.
- Check and process that inbox reliably (daily).
Tagging conventions (example)
- Use very few, clear tags: fleeting, literature, atomic, project.
- Tags should indicate note type and processing state.
Daily processing routine (practical, repeatable)
- Open your spaced-repetition review for notes tagged fleeting (or run whatever morning review command you use).
- For each presented fleeting note, decide quickly:
  - If it’s a task that takes under 2 minutes: do it immediately, then delete the fleeting note.
  - If it belongs to an existing project (e.g., shopping list): paste it into that project note and delete the fleeting note.
  - If it’s unclear or not actionable now: “snooze” it with spaced repetition (schedule it for future review). This prevents backlog overload while preserving items that might matter later.
  - If it’s clearly irrelevant: delete it.
  - If it’s a factual snippet (name, code block, address): create a small factual note with sensible tags for later retrieval.
  - If it’s a substantive insight/idea: expand it into an atomic note immediately, keep the original capture as reference, and retag it as atomic.
Processing literature highlights
- Right after reading or listening, expand useful highlights into atomic notes or link them into existing atomics.
- Some highlights become atomic notes, some are referenced in existing notes, and some are snoozed to review later.
- If using a highlights importer that outputs markdown checkboxes (e.g., Readwise templates), check the box when processed.
Creating atomic notes
- Write the idea in your own words as simply as possible; include references and cross-reference related atomics in a “see also” section.
- File the atomic note behind exactly one closely related note (use an “up” property or parent link) to build a browsable tree; use normal links for other relationships.
- Give atomic notes human-readable filenames that jog your memory without opening the file.
- Add an atomic tag to indicate the note is processed.
Use spaced-repetition tooling to scale the backlog
- Use an Obsidian Spaced Repetition plugin or Anki to:
  - Present only the highest-priority or previously-marked-hard fleeting notes each day (others are snoozed).
  - Reduce the visible backlog to what’s worth processing now.
- When you snooze a note, plugin metadata (due date + difficulty/urgency counters) is added so the system can reliably resurface it later.
Organization and navigation tips
- Prefer a scrollable tree (example: Vert Folder plugin) or linear card-style browsing over trying to read a dense graph UI.
- Use uplinks/parent pointers to keep related knowledge physically close in the tree, enabling intuitive browsing.
- Keep references to literature notes (and original wording) inside your atomic notes for provenance.
Output stage (brief)
- Once you have many loosely coupled, highly cohesive atomic notes, compose them into essays, exam revision, scripts, or projects by clustering and adding connective text (glue).
- The final video in the series covers time-boxed projects and project details.

Practical tips & principles emphasized

Process daily — especially fleeting notes — because yesterday’s you relied on today’s you to handle them.
Use small rules to avoid decision paralysis: 2-minute rule, project move, snooze, delete, atomic convert.
Keep the system minimal and scalable: single inbox, few tags, human-readable filenames.
The utility of a mature Zettelkasten-like system is that you rarely start from scratch; atomic notes let you stack and glue for drafts quickly.
Use tooling (Obsidian + plugins) to automate scheduling and to visualize the tree, but keep file-level, human-readable organization.

Tools, plugins, books & concepts referenced

Zettelkasten method (atomic notes / main/permanent notes)
FLAP system (Capture, Process, Write — the presenter’s system)
Obsidian (note-taking vault)
Vert Folder plugin (tree visualization)
Spaced Repetition plugin for Obsidian (Stephen Wang referenced)
Readwise (highlights importer templates)
Anki (alternative spaced-repetition tool)
“A System for Writing” — Bob Doto
“Getting Things Done” — David Allen
“How to Take Smart Notes” — Sönke Ahrens
Niklas Luhmann (historical Zettelkasten example)
2-minute rule (productivity rule used during processing)

Speakers / sources featured or explicitly named

Tris (presenter / creator of the video and system shown)
Morgan (fellow YouTuber demonstrating physical Zettelkasten cards)
Bogdan (runs Let’s Get Rusty — sponsor mentioned)
Bob Doto (author — A System for Writing)
David Allen (author — Getting Things Done)
Sönke Ahrens (author — How to Take Smart Notes)
Niklas Luhmann (historical Zettelkasten practitioner)
Stephen Wang (developer of an Obsidian Spaced Repetition plugin)
Carl Sagan (misquoted briefly)
Tools/communities also referenced: Obsidian, Vert Folder plugin, Spaced Repetition plugin, Readwise, Anki, Let’s Get Rusty