Get AI summaries of any video or article — Sign up free
Designing Ideas: How Jonathan Splitlog uses the LYT frameworks (Obsidian) thumbnail

Designing Ideas: How Jonathan Splitlog uses the LYT frameworks (Obsidian)

5 min read

Based on Linking Your Thinking with Nick Milo's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

A single home note anchors the system, and it links outward only to a limited set of index-style home maps to keep navigation intentional.

Briefing

Jonathan Splitlog’s Obsidian system is built to turn scattered reading, listening, and conversations into “mature,” evergreen knowledge—organized through a stack of maps-of-content (MOCs) that always trace back to a single home note. The core move is structural: everything starts from a top-level home note, then fans out only into a small set of index-style home maps, each of which links to deeper MOCs and ultimately to source-driven notes. That design matters because it prevents ideas from becoming isolated bookmarks; instead, they accumulate into coherent, retrievable bodies of work.

At the top sits a “home note” that functions as the launching point for the entire system. From there, the only outward links go to “home maps” (indexes). One of Splitlog’s key home maps is “interest,” which acts as the stitching layer between different kinds of notes: source notes, developing notes, and more “mature” evergreen notes. The interest MOC is organized by categories—such as “computers and technology”—and each category links to further MOCs. For a capstone-focused thread, Splitlog worked on a specific MOC titled “mystical computation,” a research direction examining human-computer interaction through the lens of mysticism and spirituality.

The “mystical computation” MOC is described as both bottom-up and evergreen. Splitlog starts by taking notes from materials encountered over time, then later discovers which notes “belong” together under a home. As the MOC grows, it gains contextual scaffolding: it doesn’t just link to related ideas, it explains how those ideas connect to the central topic. Even if a note began life as something else—like “spatial awareness and digital environments”—the system allows that note to live under “mystical computation” by adding context that clarifies why the connection exists. This is the practical difference between collecting and synthesizing.

Source materials sit alongside the synthesis layer. Splitlog is “source driven,” beginning most idea formation with reading, listening, or conversations. In the “mystical computation” MOC, source notes are linked in a way that avoids repetitive manual linking; instead, backlinks help surface relevant sources automatically. A documentary example, “All Watched Over by Machines of Loving Grace,” illustrates how a source note can be mined selectively: only one heading from the documentary note is embedded into the MOC, pulling a specific argument into the evergreen structure. In Obsidian terms, that’s done via heading embeds, so the MOC can reuse a precise slice of a larger source note.

Splitlog also contrasts this detailed, class-focused MOC with a more straightforward “computer history” MOC. The difference is not just topic; it’s how the system balances categories. “Computer history” is organized using the same top-level categories found in the home note—interest, concepts, sources, reference, education, writing, documentation, and meta notes—then uses the MOC practice to stitch original ideas to encountered materials and reference points. The end goal is publication-ready thinking: MOCs become springboards for writing, while term-definition notes (e.g., defining “mystical computation”) ensure the system remains usable when returning to the work later. The result is a workflow that reliably moves from raw inputs to structured, contextual knowledge that can be revisited and turned into output.

Cornell Notes

Jonathan Splitlog’s Obsidian workflow uses a layered “map of content” system to convert reading, listening, and conversations into evergreen knowledge. A single home note links outward only to a small set of index-style home maps, including an “interest” MOC that organizes categories like “computers and technology.” From there, deeper MOCs—such as “mystical computation”—stitch together source notes, developing ideas, and mature evergreen notes using added context that explains why each note belongs. Splitlog mines sources selectively by embedding specific headings from source notes into the MOC, rather than dragging entire documents into the synthesis layer. The payoff is retrieval and publication readiness: MOCs become coherent structures that support later writing and re-entry, including defined terms and contextual explanations.

How does Splitlog’s system prevent ideas from staying as disconnected bookmarks?

Everything funnels through a top-level “home note” that serves as the launching point. From that home note, links only go to “home maps” (indexes). The “interest” home map then stitches together source notes, developing notes, and mature evergreen notes by organizing categories (e.g., “computers and technology”) and linking to deeper MOCs. In the “mystical computation” example, notes that started as separate topics (like “spatial awareness and digital environments”) are placed under the MOC by adding contextual explanation—so the system records not just what was read, but why it matters to the central theme.

What makes a MOC “evergreen” in this workflow?

An evergreen MOC isn’t just a list of links. Splitlog emphasizes contextualization: the MOC contains rich information explaining how related ideas tie back to the central concept. For “mystical computation,” the MOC contextualizes multiple notes to the main research direction (human-computer interaction through mysticism and spirituality). That means the structure remains useful even if a note was originally collected for a different reason; the MOC adds the “why,” turning scattered inputs into a coherent, revisitable body of knowledge.

How does Splitlog reuse content from a source note without importing everything?

He uses heading embeds in Obsidian. In the documentary source note for “All Watched Over by Machines of Loving Grace,” the MOC doesn’t embed the whole document note. Instead, it embeds a specific heading (a particular argument slice) into the “mystical computation” MOC. This selective embedding keeps the MOC detailed and relevant while avoiding clutter from unrelated parts of the source.

What role do backlinks play in managing source notes?

Splitlog avoids manually linking every new source note into the system. For example, in the “sources” area tied to the reading notes, he doesn’t add a link each time a new source note appears; backlinks surface the connections automatically. That reduces maintenance overhead while still keeping the source layer discoverable and connected to the MOCs that reference it.

How does the “computer history” MOC differ from “mystical computation,” and what stays consistent?

The “computer history” MOC is more straightforward and non-fiction oriented, with notes organized along the same category framework used in the home note: interest, concepts, sources, reference, education, writing, documentation, and meta. The consistent part is the stitching logic: original ideas connect to encountered sources and reference materials, then get contextualized so they can be found again and used for writing. The difference is depth and emphasis—“mystical computation” is described as more detailed and context-heavy because it was a focused class/capstone effort.

Why does Splitlog keep a separate note for definitions even inside a mature MOC?

Even when a MOC has context, Splitlog still maintains a dedicated term-definition note to ensure clarity and reusability. For instance, when returning to “mystical computation,” he needs a note defining the term. This supports later writing and publication work by preventing ambiguity and keeping key concepts standardized across the system.

Review Questions

  1. In Splitlog’s structure, what is the functional difference between the home note, home maps (indexes), and a specific MOC like “mystical computation”?
  2. How does heading embedding change the way source material contributes to an evergreen MOC? Provide the documentary example and what gets embedded.
  3. What categories appear in Splitlog’s home note framework, and how does that framework shape the organization of a MOC such as “computer history”?

Key Points

  1. 1

    A single home note anchors the system, and it links outward only to a limited set of index-style home maps to keep navigation intentional.

  2. 2

    An “interest” MOC acts as the stitching layer that connects source notes, developing notes, and mature evergreen notes by category.

  3. 3

    MOCs become evergreen through contextualization—adding explanations that justify why each related note belongs under the central theme.

  4. 4

    Selective reuse of sources is done via heading embeds, allowing only the relevant slice of a source note to appear inside a MOC.

  5. 5

    Backlinks reduce manual linking work by surfacing connections automatically as new source notes are added.

  6. 6

    Different MOCs can vary in depth (e.g., capstone-focused vs. straightforward non-fiction), but the stitching workflow and category framework stay consistent.

  7. 7

    Term-definition notes remain necessary even inside mature MOCs to keep key concepts precise for later writing and publication.

Highlights

“Mystical computation” is built as an evergreen MOC by contextualizing multiple notes—sometimes collected for other reasons—so they clearly connect back to the central research theme.
Heading embeds let a MOC pull in only one relevant section from a larger source note, keeping synthesis precise rather than cluttered.
Backlinks are used to avoid repetitive manual linking of every new source note into the system.
The system’s navigation logic is strict: everything traces back to a home note, then funnels through a small set of home maps before reaching deeper MOCs.

Topics

Mentioned