Get AI summaries of any video or article — Sign up free
Helping a beginner understand Logseq thumbnail

Helping a beginner understand Logseq

CombiningMinds·
5 min read

Based on CombiningMinds's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Organize around “project” pages that contain a “questions” section, then connect each question to a “people to speak to” block so research becomes actionable.

Briefing

Logseq can work as a research-and-publication workspace if notes are organized around “projects” and “questions,” then connected to the people who can answer them—using indentation, tags, and filters rather than folders. A practical workflow emerges: create a project page (e.g., “basic income grant”), add a “questions” section under it, and link each question to a “people to speak to” block. Over time, those questions can expand into fuller answers, turning scattered reading into a structured knowledge base that’s easy to revisit.

The session also challenges a common beginner instinct: splitting everything into separate graphs. One approach keeps everything in a single graph so information can be resurfaced across contexts through keyword search and tag-based queries. That matters because a single question often connects multiple domains—economic policy, social housing, and related institutions—so filtering a unified graph can reveal cross-cutting relationships. The tradeoff is psychological as much as technical: a large one-graph setup can feel overwhelming, and it may not “prompt” the right queries organically. Still, the workflow leans on Logseq’s ability to filter by tags like “questions,” “social housing,” or “basic income grants,” effectively recreating the same view you’d get from a more compartmentalized system.

Indentation is treated as more than formatting—it’s a way to encode meaning. When a question is nested under parent blocks (for example, “questions” → “iej” → “social housing”), the nested structure becomes inheritable context. That means the same question can be found and filtered later even if it was created in a stream-of-consciousness way. The session demonstrates that tags and indentation work together: tags act like cross-references, while indentation preserves the local hierarchy that makes retrieval intuitive.

The notes also cover how to build navigation inside Logseq. A “table of contents” can be created without heavy linking by using chapter-like pages or sections that can be collapsed during active work, then jumped to later via graph view. For content production, that navigation becomes a practical memory aid—especially when research and video-making happen weeks apart. Checklists and “how-to” pages (like a repeatable process for highlighting animations) are positioned as reusable references that reduce the need to rediscover steps.

Finally, the session introduces two ways to model “projects.” One uses metadata-style titles (e.g., “type:: project”) so project pages appear as nodes and can be queried like an index. Another uses title namespaces (hierarchical prefixes in titles) to group projects into a visible structure in graph view. The overall takeaway is less about finding a single correct system and more about iterating on workflows: start with one graph, tighten indentation and tagging, then adjust structure over a few weeks as new questions appear. The goal is a system that supports both research publication and the day-to-day mechanics of returning to work months later.

Cornell Notes

A workable Logseq setup centers on projects and questions, then connects each question to the people who can answer it. Keeping everything in one graph enables cross-topic retrieval through tags and filters, even when notes were created in a stream-of-consciousness style. Indentation encodes hierarchy: nested blocks inherit context, so a question under “questions → ie j → social housing” can be found later by filtering tags or navigating the parent structure. Navigation features like chapter-style sections and graph view help users jump back into active work. The session also compares project modeling via metadata (e.g., “type:: project”) versus title namespaces, emphasizing workflow iteration over “one right way.”

How does a “project → questions → people to speak to” structure turn research into something actionable?

The workflow starts with a project page (for example, “basic income grant”). Under that page, a “questions” section holds specific research questions. Each question then links to a “people to speak to” block—so the database doesn’t just store what to research, but also who to contact. As answers accumulate, those question blocks can be expanded progressively, turning reading and inquiry into a publication-like draft.

Why keep everything in one Logseq graph instead of creating a separate graph per project?

A single graph makes it possible to resurface information across domains using tags and filters. If “questions” are tagged with both “social housing” and “basic income grants,” the same query view can show relevant questions for either project. With separate graphs, that cross-project filtering becomes harder because the data is siloed; the session frames one-graph organization as a design philosophy for seamless retrieval.

What role does indentation play beyond visual structure?

Indentation encodes meaning through parent-child inheritance. When a question is nested under parent blocks (e.g., “questions” → “iej” → “social housing”), the child block inherits the context of its parents. That means the question can be retrieved later even if it was entered quickly or later moved conceptually—because the hierarchy and tags preserve relationships.

How can tags replicate the benefits of a more rigid folder structure?

Tags act like cross-references that allow the same note to appear in multiple filtered views. A question tagged with “questions” and “social housing” will show up when filtering for social housing, even if it was created under a different page. The session describes this as equivalent to using a spreadsheet filter: you can enter notes freely, then slice them later by project tags.

What are two ways to model “projects” so they appear as navigable nodes?

One method uses metadata-style titles such as “type:: project,” which creates a “projects” page that links to project entries and forms a map-like index in graph view. Another method uses title namespaces (hierarchical prefixes in titles) so projects appear grouped under a hierarchy in graph view. The session notes that namespaces are a common technique, though the user is still experimenting with whether it will be a long-term preference.

How can a table of contents improve day-to-day work in Logseq?

Chapter-like sections can be created as collapsible structures so work stays focused while still preserving quick jump points. Later, graph view can be used to navigate to those chapters or sections. This is positioned as especially useful when research and production tasks (like video editing and animation steps) are separated by weeks.

Review Questions

  1. If a question is nested under multiple parent blocks in Logseq, how would that affect later retrieval when filtering by tags?
  2. What are the practical advantages and drawbacks of using one graph for everything versus multiple graphs for separate projects?
  3. How do metadata-style project tags (e.g., “type:: project”) differ from title namespaces in how projects appear and are navigated in graph view?

Key Points

  1. 1

    Organize around “project” pages that contain a “questions” section, then connect each question to a “people to speak to” block so research becomes actionable.

  2. 2

    Use one graph when cross-topic retrieval matters; rely on tags and filters to resurface notes across projects.

  3. 3

    Treat indentation as semantic structure: nested blocks inherit context, making stream-of-consciousness entry still retrievable later.

  4. 4

    Combine tags with hierarchy: tags enable cross-cutting views (e.g., filter all “questions” for “social housing”), while indentation preserves local meaning.

  5. 5

    Build internal navigation with chapter-style sections and graph view so users can collapse work areas and jump back quickly.

  6. 6

    Model projects either with metadata-style tags like “type:: project” (index-like navigation) or with title namespaces (hierarchical grouping).

  7. 7

    Iterate on workflow over time; the “best” structure is the one that supports how new questions and production tasks actually unfold.

Highlights

A research workflow becomes practical when questions are linked to specific people, not just stored as text.
One-graph organization supports cross-project filtering through tags, even when notes were created in a messy, fast way.
Indentation isn’t cosmetic in Logseq—parent-child nesting carries context that later filters can exploit.
Chapter-style sections plus graph view can function as a navigable table of contents during long projects.
Projects can be indexed via metadata (e.g., “type:: project”) or grouped via title namespaces, both changing how graph view surfaces structure.

Topics

Mentioned