Get AI summaries of any video or article — Sign up free
GTD: Getting Things Done in Logseq thumbnail

GTD: Getting Things Done in 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

Use a single capture tag (e.g., inbox) and add tags/properties immediately so capture, clarification, and organization happen in one pass.

Briefing

Getting Things Done (GTD) in Logseq works best when capture, clarification, and organization happen immediately—using tags, properties, and keyboard shortcuts—so tasks and reference material resurface with the right context later. The core move is to translate GTD’s “inbox → next actions → review” flow into Logseq’s block-level workflow, then standardize how metadata is added at the moment something enters the system.

Instead of waiting to clean things up later, the workflow starts by funneling everything into a single capture tag (for example, an “inbox” hashtag). From there, Logseq blocks can be pulled together under chosen tags or backlinks, letting users defer decisions like “someday” or “reference” without losing the ability to find the item quickly. The transcript emphasizes upfront thinking about what context will be needed when information is revisited—comparing it to searching WhatsApp chat history or using a couple of keywords in Google. In practice, that means choosing tag keywords that match how the user would actually search.

Calendar and time-based actions get handled through Logseq’s slash commands and built-in properties. Typing “/scheduled” or “/deadline” opens a menu to attach calendar-based information to a block. The “to do” property can be inserted via Control + Enter, while waiting states can be added by typing “waiting” (or selecting it from the “/” menu). For reference items, the approach leans on metadata: set a “type” property to “reference,” then add tags that reflect likely search terms—such as whether the item is about a project, a person, or a topic. “Someday” items use a consistent tag (the transcript mentions “somday” and notes that namespaces are created but the key is using them consistently).

For reminders, the transcript contrasts Logseq’s space repetition feature with a simpler navigation-based method: using “/read” and “/watch” commands to create quick routes to items, then relying on hierarchy to find them fast. Items that no longer matter can be removed by tagging “trash” or deleting the block.

The workflow then maps GTD’s “who/where/what” thinking into metadata triggers. “Who” can be captured with an “@” mention so queries can quickly pull up all blocks tied to a person. “Where” can be captured with “@” or “$”-style context tags (e.g., “home,” “work,” “shops”) so the same note can be retrieved based on location rather than forcing it into a single project category. “What” becomes the action itself: email, call, buy, or other next steps. The transcript suggests using a “next” tag for actionable items, then removing it once the action is done.

Finally, the system supports running agendas and reviews by filtering blocks by inbox, person, and project namespaces. Reference and action items can be organized into project hierarchies so users can collapse and navigate quickly. Dashboards—built with Logseq queries and potentially advanced queries later—are positioned as the next step for higher-level review, with examples like a home page that aggregates projects, reminders, and “to do” lists through queries and namespace navigation.

Cornell Notes

The transcript lays out a GTD-to-Logseq workflow built around immediate metadata capture. Everything enters via a single “inbox” tag, then blocks are clarified and organized right away using Logseq tags/properties rather than postponing cleanup. Time-based actions use “/scheduled” and “/deadline,” while “to do” is added via Control + Enter and waiting states via “waiting” or the “/” menu. Reference and “someday” items rely on properties like type=reference plus search-oriented tags (project/person/topic). The payoff is fast retrieval: filter by person (“@”), context (“@”/“$”), and project namespaces to maintain running agendas and review lists, with dashboards as a future upgrade.

How does the workflow translate GTD’s capture/clarify/organize cycle into Logseq in a way that speeds up later retrieval?

It consolidates GTD’s stages at the block level. New items are captured under a single hashtag inbox (or similar), then clarified immediately by adding metadata—tags and properties—so the same block can later be resurfaced by the context a user would search for (keywords like who/where/what). The transcript stresses that upfront tag choices matter because retrieval later depends on those search terms, not on a perfect long-term taxonomy.

What concrete Logseq commands and properties are suggested for time-based actions and task states?

Time-based actions use slash commands: “/scheduled” and “/deadline,” which open a menu to attach dates (and times). Task status uses the built-in “to do” property, inserted with Control + Enter. Waiting states can be added by typing “waiting” in capitals or selecting “waiting” from the “/” menu.

How are reference and “someday” items handled differently from next actions?

Reference items get a properties-based approach: set a “type” property to “reference,” then add tags that reflect likely search targets such as project, person, or topic. “Someday” items use a consistent tag (the transcript notes namespaces may be created, but consistency is the goal). Unlike next actions, these items aren’t necessarily tied to immediate execution; they’re optimized for later recall.

How does the system use metadata triggers like who/where/what to build running agendas?

“Who” is captured with an “@” mention so queries can quickly find all blocks tied to a person. “Where” uses context tags such as home/work/shops so retrieval can be filtered by location rather than forcing everything into a single project. “What” is the action type (email, call, buy), and actionable items can be marked with a “next” tag that gets removed after completion. Filtering by inbox + person yields a running agenda of items to discuss or handle.

What role do namespaces and project hierarchies play in navigation and review?

Namespaces help collapse and navigate project structure. Instead of relying on “type projects” inside project pages, the transcript describes using a namespace hierarchy for projects so users can open a projects page and see a full hierarchy at a glance. This supports quick filtering and reduces buried linked-reference clutter.

Why are dashboards mentioned, and how do they fit into the GTD workflow?

Dashboards are positioned as an escalation of the review layer: using Logseq queries (and possibly advanced queries later) to aggregate reminders, projects lists, and “to do” items on a home page. The transcript treats dashboards as a way to make review more powerful once the metadata and namespace structure are already working.

Review Questions

  1. If a note is meant to be revisited later but not acted on immediately, what properties/tags would you use (based on the transcript’s reference vs. someday approach)?
  2. Which Logseq inputs would you use to attach a deadline and mark a task as waiting, and how would those choices affect later filtering?
  3. How would you design your tag keywords so that searching later (like the WhatsApp/Google analogy) reliably brings back the right blocks?

Key Points

  1. 1

    Use a single capture tag (e.g., inbox) and add tags/properties immediately so capture, clarification, and organization happen in one pass.

  2. 2

    Choose tag keywords based on how you’ll actually search later; retrieval depends on those upfront metadata decisions.

  3. 3

    Attach calendar actions with “/scheduled” and “/deadline,” and manage task states with the built-in “to do” property (Control + Enter) and “waiting.”

  4. 4

    Mark reference items with properties like type=reference plus search-oriented tags (project/person/topic), and use a consistent “someday” tag for deferred items.

  5. 5

    Use metadata triggers for context: “@” for who, context tags for where (home/work/shops), and action tags like “next” for what to do next.

  6. 6

    Build running agendas by filtering blocks by inbox and person, then use project namespaces to navigate and review without burying items in linked references.

  7. 7

    Consider dashboards (query-based home pages) as a later upgrade to centralize reminders, projects, and to-do lists for review.

Highlights

The system’s biggest efficiency gain comes from doing GTD clarification and organization at the moment of capture, not as a later cleanup task.
Time-based actions are handled directly in Logseq with “/scheduled” and “/deadline,” while task states use Control + Enter for “to do” and “waiting” for pending work.
Reference material becomes searchable by combining a type property (type=reference) with tags that mirror real search terms like project and person.
Running agendas emerge naturally by filtering inbox items by person, turning scattered notes into a focused list of what to discuss next.
Namespaces are used to create a navigable project hierarchy so review doesn’t depend on digging through linked references.

Topics

Mentioned