Get AI summaries of any video or article — Sign up free
How Lionel Davoust writes fiction books using the LYT Frameworks (Obsidian) thumbnail

How Lionel Davoust writes fiction books using 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

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?

Davoust compares a tesseract (a four-dimensional extension of a cube) to how fiction works: readers experience stories one sentence at a time, but writers must manage a multi-dimensional construct—characters’ motives, emotions, sensory details, and causal consequences. In long sagas with many characters and timelines, chapter-one decisions can echo far later, so the writer needs a way to keep many interdependent elements coherent without relying on memory alone.

How do the LYT Frameworks turn scattered ideas into story structure?

He uses a loop: a “light bulb” captures an idea; refining it produces a hypothesis (the arrow). As writing proceeds, constraints become durable—his example is that if a character doesn’t like cake in chapter one, that dislike shouldn’t vanish by chapter five (the exclamation mark meaning the story’s internal consistency). The system also forces attention to “red question marks,” the difficult questions (scene location, character goals, aims) that must be answered to move forward.

Why does he treat first drafts differently from rewriting?

Davoust says creativity isn’t about immediately finding all answers; it’s about identifying the right questions. In his workflow, the first draft primarily surfaces and sequences those questions. Once answers exist, rewriting becomes the phase where the answers are improved—tightening logic, consistency, and emotional or thematic fit across the whole structure.

What does “emergence” look like in his Obsidian setup?

He describes capturing fragments—scene ideas, punchlines, and world details—as separate atomic notes, then letting links reorganize them into “maps of content” (character arcs, story arcs, world sections). He reports that it becomes difficult for ideas not to build on each other: new notes keep feeding the graph, and decisions and choices “emerge” from the evolving network rather than from a rigid outline.

How does he handle the need for constant refactoring?

Because story elements depend on everything else, he treats refactoring as ongoing. He finds block references slow refactoring when notes must be split or renamed, so he prefers creating new notes and embedding them. Renaming and re-linking is easier, which keeps the system fluid as the story’s structure changes.

What principle keeps his system from turning into endless worldbuilding?

Davoust repeatedly says the end goal isn’t worldbuilding for its own sake; it’s writing the story. He uses maps of content to jump into the right questions and then convert ideas into hypotheses that support scenes. Even when he builds franchise-level structures later, the purpose is to preserve canon so it can continue to serve future writing.

Review Questions

  1. How does the “tesseract dilemma” change the way you should think about outlining or planning a novel?
  2. In Davoust’s LYT loop, what roles do light bulbs, arrows, exclamation marks, and red question marks play?
  3. What tradeoff does he make when choosing between block references and creating new notes for refactoring?

Key Points

  1. 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. 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. 3

    Progress depends on identifying “red question marks”—the hard unknowns (scene setting, goals, aims) that block writing—then sequencing them through drafts.

  4. 4

    First drafts function mainly to surface and order questions; rewriting focuses on improving the answers and tightening story coherence.

  5. 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. 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. 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.

Highlights

The “tesseract dilemma” reframes writing as compressing a four-dimensional story reality into the one-dimensional act of reading.
Davoust’s LYT loop turns ideas into hypotheses and then into durable constraints—like keeping a character’s dislike of cake consistent across chapters.
He treats refactoring as built-in: story interdependence requires continuous rebalancing, not a one-time outline.
Maps of content in Obsidian act like modular tables of contents that let questions, ideas, and hypotheses assemble into structure.
He uses emojis in filenames as quick navigation cues for jumping back to unresolved questions or promising ideas.

Topics

  • LYT Frameworks
  • Tesseract Dilemma
  • Obsidian Graph
  • Maps of Content
  • Refactoring Workflow

Mentioned