How Lionel Davoust writes fiction books using the LYT Frameworks (Obsidian)
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.
Davoust frames long-form fiction as a multi-dimensional problem that must be managed despite reading being linear, using the “tesseract dilemma” to explain the cognitive challenge.
Briefing
Lionel Davoust’s core claim is that long-form fiction becomes manageable when the writing process is treated like a system for handling “multi-dimensional” story knowledge—ideas, uncertainties, character arcs, and world rules—rather than a linear outline. He frames the central challenge as the “tesseract dilemma”: fiction asks writers to compress a four-dimensional construct (characters’ motives, moods, causes, and consequences) into the one-dimensional experience of reading sentence by sentence. The payoff, he says, is a workflow that lets story structure emerge while keeping the writer oriented amid complexity.
Davoust builds his approach around the LYT Frameworks in Obsidian, using a loop that turns raw ideas into increasingly testable story hypotheses. In his model, a “light bulb” captures an idea; refining it produces a hypothesis (the “meaning of the arrow”); and writing forces constraints to lock in over time—his example being that if a character dislikes cake in chapter one, that dislike should persist into later chapters. He also emphasizes the “red question mark”: the hard questions that block progress, such as where a scene takes place, what the characters want, and what the scene’s goal is. First drafts, he argues, are less about producing answers and more about surfacing and sequencing those questions; rewriting then becomes the work of improving the answers.
In practice, he describes how Obsidian’s atomic notes and linking make emergence feel natural. Random scene fragments, punchlines, and world details get captured as separate notes, then reorganized into “maps of content” that function like modular tables of contents for characters, arcs, and the world itself. He reports that this structure makes it hard for ideas to “stall,” because new notes keep feeding the graph, and because the unknowns are explicitly identified as parts of the system rather than floating in his head.
He also stresses constant refactoring. Because story elements influence one another across chapters, he treats the system as something that must be continuously rebalanced—like refactoring a living model rather than freezing a plan. He warns that heavy use of block references can slow refactoring; his workaround is to create new notes and embed them, since renaming and relinking is easier when the structure shifts. He uses emojis in filenames as quick “jumping points” to mark questions or ideas he wants to revisit.
Davoust’s screenshots illustrate three main graph clusters: the intricate map for the book in progress, a cast-under-construction area for characters, and a separate workspace for workshop notes and observations that later feed into the main canon. He repeatedly returns to a guiding principle: worldbuilding is only valuable insofar as it helps write the story. The system ultimately supports a later transfer step—moving published canon into a franchise-level vault with the same structure.
Beyond tooling, he positions the method as psychological relief. Compared with file-and-folder workflows that can feel messy and anxiety-inducing, the graph-based approach gives him an overview of the unknowns and lets him “pin” questions so they don’t haunt working memory. The result is a workflow designed to keep momentum—trusting emergence while maintaining an overarching purpose: write the damn thing.
Cornell Notes
Lionel Davoust describes fiction writing as a “tesseract dilemma”: a four-dimensional story reality must be squeezed into the one-dimensional experience of reading. Using the LYT Frameworks inside Obsidian, he captures ideas as “light bulbs,” refines them into hypotheses (arrows), and uses “red question marks” to identify the hard unknowns that block progress. He treats first drafts as question-sequencing and rewriting as answering those questions better. His Obsidian graph organizes atomic notes into “maps of content” for characters, arcs, and world rules, with constant refactoring to keep chapter-to-chapter consequences consistent. The method matters because it reduces cognitive load and turns uncertainty into an explicit, navigable system rather than something stored in his head.
What is the “tesseract dilemma,” and why does it matter for long fiction?
How do the LYT Frameworks turn scattered ideas into story structure?
Why does he treat first drafts differently from rewriting?
What does “emergence” look like in his Obsidian setup?
How does he handle the need for constant refactoring?
What principle keeps his system from turning into endless worldbuilding?
Review Questions
- How does the “tesseract dilemma” change the way you should think about outlining or planning a novel?
- In Davoust’s LYT loop, what roles do light bulbs, arrows, exclamation marks, and red question marks play?
- What tradeoff does he make when choosing between block references and creating new notes for refactoring?
Key Points
- 1
Davoust frames long-form fiction as a multi-dimensional problem that must be managed despite reading being linear, using the “tesseract dilemma” to explain the cognitive challenge.
- 2
The LYT Frameworks loop captures ideas as light bulbs, refines them into hypotheses with arrows, and uses consistency constraints so early story facts persist later.
- 3
Progress depends on identifying “red question marks”—the hard unknowns (scene setting, goals, aims) that block writing—then sequencing them through drafts.
- 4
First drafts function mainly to surface and order questions; rewriting focuses on improving the answers and tightening story coherence.
- 5
Obsidian’s atomic notes and linking let ideas reorganize into “maps of content” for characters, arcs, and world rules, supporting emergence rather than rigid planning.
- 6
Constant refactoring is treated as normal because chapter-to-chapter consequences ripple across the saga; he prefers creating and embedding new notes over relying on block references when structures change.
- 7
A graph-based system reduces anxiety by externalizing unknowns and “pinning” questions outside working memory, while keeping the overarching goal fixed: write the story.