Add Smart Notes to the slip box in Obsidian
Based on Joshua Duffney's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Insert notes into the correct sequence position when their relationships fit between existing notes, using sequence naming to preserve logical branching.
Briefing
Smart Notes in Obsidian get “smart” only after a disciplined filing workflow: create a sequence when a new note belongs between existing ones, add explicit note-to-note links for looser relationships, and then ensure every note is discoverable through an index. The payoff is a slip box where ideas don’t vanish into the file system—connections become navigable highways, and backlinks keep the structure intact as notes evolve.
In the physical slip box, the process starts with permanent notes filed in order. When a new note turns out to relate more closely to an earlier note than its current position would suggest, it gets inserted into a sequence using a naming convention like “2a” placed after note 2. If the new note doesn’t fit tightly into any sequence, it’s simply numbered at the end. After that, relationships that are real but not directly “building on” the same argument are captured with indicators—such as marking a link to note 4—so the connection survives even when the note isn’t part of the main sequence.
The final physical requirement is discoverability: the note must appear in the index somewhere, either directly or via a chain of linked notes. Without that, the note is effectively lost. Digital Obsidian loosens some constraints because search and backlinks can help, but the index still matters because it preserves the slip box’s link structure and prevents knowledge from becoming orphaned.
The digital workflow mirrors the physical one but leans on Obsidian’s linking and automatic updates. Notes are still added behind a related note, and sequences are created by naming with a prefix/id so the file system order reflects the branching structure (often aligning with timestamps for chronological behavior). Instead of relying solely on naming to categorize, the system uses links: highlight a phrase in the source note, create a link to the target note (using an alias if needed), and let Obsidian maintain backlinks.
A practical example shows creating a new literature note, linking it to an existing permanent note, then renaming it into a sequence id (e.g., updating “untitled” to a sequence-labeled name) so backlinks remain consistent. Next comes note-to-note linking: a new permanent note is created to capture an elaboration insight, then linked to the earlier note by selecting a relevant passage and inserting a link. Obsidian’s local graph view helps visualize these connections, making it easier to see what’s connected without physically laying cards out.
Once sequences and links exist, the system’s “index” step becomes the gateway to the whole knowledge base. An index note (a “MOC,” or map of content) acts as the central entry point. Rather than building a rigid top-down library, the index grows bottom-up as branches develop—eventually resembling an outline or manuscript structure. Keywords in this framework are broader anchors (like “permanent notes” or “note sequences”) that can hold many linked ideas beneath them. After assembling the index, notes can be moved from a staging root directory into the slip box, and the index becomes the primary navigation method.
The workflow ends by pointing to the next layer of structure: hub notes (structure notes) that organize the slip box further—beyond sequences and keyword-based indexing—so knowledge can be assembled into writing-ready frameworks.
Cornell Notes
Smart Notes in Obsidian rely on three linked steps: (1) insert new permanent notes into the right sequence position when they fit more closely between existing notes (using sequence naming like “2a”), (2) create note-to-note links for looser relationships so ideas remain connected, and (3) add everything to an index (MOC) so notes stay discoverable. Obsidian’s backlinks and automatic link updates help maintain integrity when note names change, while local graph views make connections easier to understand. Keywords in the index act as broader anchors (e.g., “permanent notes,” “note sequences”) under which many linked notes can accumulate. The index becomes the main navigation path, replacing file-system browsing.
Why does the workflow require sequences (like “2a”) instead of simply numbering every new note at the end?
What’s the difference between sequence placement and note-to-note linking?
Why does an index (MOC) remain essential even though Obsidian supports search?
How do backlinks and automatic link updates reduce maintenance work in Obsidian?
What role do keywords play inside the index?
How does the local graph view support the slip box workflow?
Review Questions
- When should a new note be inserted into a sequence (e.g., becoming “2a”) rather than placed at the end of the slip box?
- What conditions must be met for a note to be reliably discoverable through the index?
- How do backlinks and link updates help maintain the slip box’s structure when note names change?
Key Points
- 1
Insert notes into the correct sequence position when their relationships fit between existing notes, using sequence naming to preserve logical branching.
- 2
Use note-to-note links to capture looser relationships that aren’t part of the main sequence argument chain.
- 3
Treat the index (MOC) as a required discoverability layer: notes must be reachable directly or indirectly through linked index paths.
- 4
Rely on Obsidian backlinks and automatic link updates to keep references consistent when notes are renamed into sequence ids.
- 5
Use local graph views and hover previews to understand connection neighborhoods without file-system browsing.
- 6
Build the index bottom-up as knowledge grows, so it eventually resembles an outline or manuscript structure rather than a rigid preplanned taxonomy.
- 7
Use keywords in the index as broader anchors (like “permanent notes” and “note sequences”) that can accumulate many linked ideas.