Get AI summaries of any video or article — Sign up free
How Mike Schmitz uses the Obsidian app as a Content Creator | LYT House Episode 2 thumbnail

How Mike Schmitz uses the Obsidian app as a Content Creator | LYT House Episode 2

6 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

Book notes start with YAML metadata and use Dataview to generate ranked, question-driven lists (e.g., best books by rating).

Briefing

Mike Schmitz uses Obsidian as a “brain map” for turning books, sermons, and writing into searchable, connected knowledge—without letting note-taking become a passive text dump. The core move is structuring notes so they can be queried later (via tags, folders, and links) and then forcing a synthesis step (like a strict three-sentence summary) so insights turn into usable thinking.

His book workflow starts with YAML metadata at the top of each note, including separate ratings (his and Joe’s) and tags that classify the entry. Dataview then pulls those ratings into sorted lists, letting him answer practical questions like “best books I’ve read” by browsing Obsidian rather than relying on memory. Each book note also links out to the book’s page, the episode’s MP3 from Libsyn, and the bookworm website links gathered at publish time. For deeper understanding, he builds a Mind Node mind map (published as an interactive iframe) and then exports the mind map to Markdown so the content can live inside Obsidian with proper headers and internal links.

A key theme is signal vs. noise. Schmitz adds “action items” from reading, tracks only incomplete tasks in a task format, and uses an emoji system (quotes, key ideas, mind-blown moments, talking-head icons) to make scanning faster. He also treats “belief” as something that changes through a learning loop: needs and beliefs drive actions and results, feedback reshapes beliefs, and the cycle repeats. That mindset shows up in how he reads and summarizes—especially in his “three-cent summary,” a constraint he uses to distill what matters into exactly three sentences. He says the difficulty of choosing what to include reinforces the same signal-vs-noise principle.

For reading strategy, he leans on Mortimer Adler’s “levels of reading” (inspectional, analytical, and synoptic/“centopical”), framing reading as a conversation where disagreement is allowed. He connects this to creativity too: after feeling blocked by the myth of originality, he draws on Austin Kleon’s “connect the dots” idea—creativity as a process of collecting and linking better inputs rather than inventing from scratch. In practice, he uses Obsidian to represent his thinking visually and structurally, including graph-based connections.

His most distinctive workflow is “atomic note taking” for sketch-note sermon study. He redraws key ideas from sermons as images in GoodNotes, then breaks scripture into one-verse-per-file “atomic” notes. Obsidian’s local graph lets him click a verse reference (e.g., Galatians 5:22) and instantly surface every sermon note that used it, giving him context and a visual memory trail. He says this helps him prepare to preach by quickly identifying themes from past sermons.

Beyond knowledge capture, he uses Obsidian for planning and review. He runs personal retreats inside Obsidian with a radar chart (via a charts view plugin) to visualize a “wheel of life” and sets goals based on low-scoring areas. He journals with “daily questions” scored 1–10, then uses the Tracker plugin to render line charts over time so he can spot dips, click into the underlying days, and adjust systems.

Finally, he manages writing projects with Kanban: article notes live in an articles folder, while a Kanban board tracks status and due dates, with drag-and-drop movement between columns. Across all these workflows, the throughline is consistent: capture in plain text, connect aggressively, and synthesize on purpose so notes become decisions, outputs, and feedback loops—not just stored quotes.

Cornell Notes

Mike Schmitz builds an Obsidian system that turns reading and study into connected, actionable knowledge. Book notes use YAML metadata plus Dataview to generate ranked lists, while Mind Node mind maps are published as interactive iframes and also exported into Obsidian Markdown for linking. He adds a synthesis constraint—summarizing each book note into exactly three sentences—to reduce signal-to-noise and force clarity. For sermon study, he uses “atomic note taking” by splitting scripture into one-verse-per-file notes and attaching sketch-note visuals, then relies on Obsidian’s local graph to retrieve all sermons that reference a verse like Galatians 5:22. He extends the same system to planning and review using radar charts, daily scored questions, Tracker line charts, and Kanban for writing projects.

How does Schmitz keep book notes from becoming a searchable pile of quotes?

He combines structured metadata with a mandatory synthesis step. Each book note starts with YAML tags (e.g., “bookworm”) and separate ratings (his and Joe’s). Dataview then compiles those into sorted lists for quick answers like “best books I’ve read.” But the bigger control is synthesis: after building the note (links, mind map content, action items), he forces a “three-cent summary” that compresses everything below into exactly three sentences. He says the constraint makes him choose what matters and reinforces a signal-vs-noise mindset.

What’s the practical purpose of the Mind Node mind map export and iframe?

The mind map serves two roles: interactive exploration and long-term integration. He publishes the mind map as an iframe so he can zoom and navigate it like a web artifact. Then he exports the mind map as Markdown and pastes it into Obsidian, preserving header structure so the content becomes linkable and searchable alongside other notes. That lets concepts (like limiting beliefs) become their own pages that can be referenced from multiple book notes.

How does “atomic note taking” change sermon study in Obsidian?

Instead of storing sermon notes as one big document, he breaks scripture into the smallest units: one verse per file. Sketch notes are created in GoodNotes on an iPad, exported as images, and transcluded under scripture references. In Obsidian, the local graph becomes a retrieval engine: clicking a verse like Galatians 5:22 jumps to every sermon note that referenced it, giving side-by-side context and preserving the visuals he drew months earlier.

What reading framework does he use to avoid trying to recreate everything he reads?

He uses Mortimer Adler’s “levels of reading.” Elementary level asks what a sentence says; inspectional reading asks what the book is about; analytical reading asks organized questions; and “centopical/synoptic” reading places books in relation to one another. He also frames reading as a conversation with the author where disagreement is allowed, which reduces the pressure to treat the author’s view as something to passively absorb.

How does he connect creativity to note-taking rather than treating it as a personality trait?

He rejects the “genius from scratch” myth and treats creativity as connecting dots. After feeling blocked by originality concerns, he draws on Austin Kleon’s idea that creation is assembling connections from existing inputs. In Obsidian terms, that means collecting better inputs (notes, visuals, references) and linking them so new outputs emerge naturally from the network of ideas.

How does he use Obsidian for review and course-correction, not just storage?

He journals with “daily questions” scored 1–10 (e.g., grow spiritually, love my wife, learn something, create something, exercise). Tags let him view both the question set and individual responses. Then the Tracker plugin renders line charts over a chosen time window (like the last quarter), so he can spot low days, click into the specific entries behind them, and identify what contributed to the dip—then design a process to prevent repeats. He also uses radar charts in charts view for personal retreat “wheel of life” planning.

Review Questions

  1. Which parts of Schmitz’s book workflow are designed for retrieval (Dataview lists, links, metadata) and which parts are designed for synthesis (three-sentence summary)?
  2. Explain how one-verse-per-file “atomic notes” interact with Obsidian’s local graph to support sermon review and preaching preparation.
  3. What mechanisms in his system help him detect and correct behavioral patterns over time (daily scoring, Tracker charts, radar chart retreats)?

Key Points

  1. 1

    Book notes start with YAML metadata and use Dataview to generate ranked, question-driven lists (e.g., best books by rating).

  2. 2

    Mind Node mind maps are used both as interactive iframes and as exported Markdown so concepts can be linked inside Obsidian.

  3. 3

    A strict “three-cent summary” forces synthesis and reduces signal-vs-noise by compressing each book note into exactly three sentences.

  4. 4

    Sermon study improves when scripture is split into atomic one-verse files, enabling local-graph retrieval by verse references like Galatians 5:22.

  5. 5

    Sketch-note visuals created in GoodNotes become long-term memory anchors when transcluded under verse-level notes.

  6. 6

    Personal retreats combine review and planning using radar charts (via charts view) to target low-scoring life areas.

  7. 7

    Writing and project throughput are managed with Kanban in Obsidian, using due dates tied to daily notes for workflow timing.

Highlights

The system’s retrieval power comes from metadata + Dataview, but its usefulness comes from synthesis constraints like the three-sentence summary.
Atomic note taking turns scripture into a graph-friendly index: every sermon that references a verse becomes instantly findable.
Creativity is treated as “connecting dots” rather than a fixed trait—notes become the input network that generates outputs.
Daily scored questions plus Tracker line charts let him diagnose low-performance days and adjust systems, not just reflect afterward.
Kanban in Obsidian keeps writing projects moving by dragging items across columns while due dates align with daily notes.

Topics

  • Obsidian Book Notes
  • Atomic Note Taking
  • Local Graph Retrieval
  • Three-Sentence Summaries
  • Sketch Notes
  • Personal Retreats
  • Kanban Writing Workflow

Mentioned