How I'm Using Logseq in 2025 - The knowledge management part of my Second Brain
Based on CombiningMinds's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Use Logseq primarily for knowledge management (ideas, references, writing) and rely on Tana for complex project management tasks like calendar-driven tracking.
Briefing
Logseq remains the core of a “second brain” setup because it’s treated as knowledge management software—not a full project-management system—and its design choices make high-density reading, fast linking, and long-form writing feel natural. After nearly five years of use, the workflow sticks around despite the existence of many alternatives, largely because Logseq supports a clear separation of roles: Logseq holds ideas, references, and writing; Tana handles project management tasks like calendars and project tracking. That division reduces the urge to force complex project workflows into Logseq’s structure, while still allowing cross-search and quick navigation between tools.
A major reason for staying is how Logseq handles reference material in an outline format. The workflow favors pages and blocks differently: information can stay as blocks for quick scanning, but it can be elevated to pages when deeper context is needed. References appear in a scrollable, reverse-chronological outline with link references visible at a glance, which the user contrasts with systems where imported content hides behind extra clicks. Filtering link references is also positioned as a practical advantage—quickly surfacing related highlights without drilling into separate pages.
Editing and writing mechanics further reinforce the choice. Markdown editing keeps notes portable for long-term use, and Logseq’s block-based editing supports drag-and-drop rearranging for long-form writing. The user also values the ability to distinguish what’s original thinking versus quoted material by using editing workflows (e.g., opening content in VS Code, replacing text, and then tracking attribution). Even small UI behaviors—like an optional non-logical outliner indentation mode—are framed as meaningful because they match how the user prefers to write and reorganize.
Still, the setup isn’t without friction. Mobile performance is described as slow and cumbersome for quick capture and search, especially on Android. Calendar integration is also called out as not robust “out of the box,” with workarounds like plugins. UI limitations occasionally slow down navigation—for example, opening a linked item doesn’t always behave as expected (such as opening as a page when that’s the desired outcome).
Questions about Logseq’s future come up because releases have slowed: the last beta was April 23, 2024, with a long gap afterward. Activity exists in issue closures and development work, but the focus is shifting to “Logseq DB,” an object-based approach inspired by Tana’s super tags. In this new direction, the traditional page-vs-block distinction may change, and tags/objects would be handled differently, with Logseq DB described as using SQLite and aiming to work with markdown files. A community manager (Ramsey) is cited as saying Logseq DB is far from finished and no timeline is committed, so current tutorials could become outdated.
To adapt, the user also tweaks adjacent workflows. Omnivore is replaced by Readwise for article capture, but imports require manual restructuring so highlights become blocks visible in the outline. Over time, the user reduces reliance on namespaces, removes scratchpad-style organization in favor of MOCs, and drops “status to process” and “observation” pressure—preferring flexible tagging (including fleeting tags) and iterative loops of thought. The takeaway is less about finding a perfect app and more about matching tools to the kind of work—knowledge management versus complex project management—and then mastering the workflow until it becomes second nature.
Cornell Notes
Logseq stays central because it’s used for knowledge management, not heavy project management. Its page/block model, high-density outline references, and fast link filtering make it easier to scan, connect, and write—especially for long-form work in Markdown. The workflow also benefits from clear separation from Tana, where calendar-based project tracking lives, while Logseq holds the thinking and reference material. Pain points remain: mobile capture/search is slow, calendar integration isn’t fully plug-and-play, and some UI behaviors are inconsistent. Looking ahead, development appears to be shifting toward Logseq DB, an object-based system inspired by super tags, with no firm timeline—so current practices may need adjustment.
Why does the workflow treat Logseq as knowledge management rather than project management?
What specific Logseq behavior makes reference material easier to use than a page-only approach?
How does the user use Logseq’s structure to support long-form writing and attribution?
What are the main pain points that prevent Logseq from being frictionless?
What’s happening with Logseq’s development, and why could it affect existing workflows?
How does the user adapt when switching article capture tools (Omnivore to Readwise)?
Review Questions
- How does separating Logseq (knowledge management) from Tana (project management) change what each tool is responsible for in the workflow?
- Which Logseq features make reference scanning faster—pages vs blocks, link references, reverse chronological ordering, or filtering—and how do they interact?
- What risks come with Logseq DB’s uncertain timeline, and what workflow elements might need rethinking if the page/block distinction changes?
Key Points
- 1
Use Logseq primarily for knowledge management (ideas, references, writing) and rely on Tana for complex project management tasks like calendar-driven tracking.
- 2
Exploit Logseq’s outline strengths: keep reference highlights visible via link references, scan in reverse chronological order, and filter link references to avoid extra navigation.
- 3
Treat pages and blocks differently: keep information as blocks for high-density scanning, elevate to pages only when deeper context is needed.
- 4
Plan around friction points—especially mobile slowness, weaker calendar integration, and occasional UI inconsistencies—by designing workflows that don’t depend on quick mobile capture.
- 5
Expect workflow changes as Logseq DB develops: an object-based, super-tag-inspired system using SQLite could alter how information is structured and displayed.
- 6
When switching capture tools (e.g., Omnivore to Readwise), be ready to adjust import handling so highlights become blocks that fit Logseq’s filtering and tagging style.
- 7
Reduce “structure pressure” over time by simplifying namespaces/scratchpads, dropping unnecessary status tags, and using flexible tagging (including fleeting tags) to support iterative discovery.