Actually getting things done with Obsidian // Checklist plugin

TL;DR

Use GTD’s capture→process→action separation to prevent mental clutter before deciding what to do next.

Briefing Cornell Notes

Briefing

A modern task system built inside Obsidian can borrow the most useful parts of David Allen’s Getting Things Done—especially the discipline of capturing work separately from doing it—then turn “what’s next?” into concrete, checkable actions. The core move is to treat task clarification as a workflow problem: projects become a set of next actions, waiting items, and “someday” ideas, all surfaced through a dedicated checklist view rather than buried in scattered notes.

The method starts with three GTD phases: capture, process, and action. Instead of trying to replicate GTD’s full “mind like water” philosophy, the approach keeps the practical separation—collect everything first so mental bandwidth isn’t consumed by deciding where thoughts belong. From there, the system leans on GTD’s insistence on clarifying the next action. Vague entries like “Do taxes” are replaced with specific, doable steps, because abstraction triggers avoidance. Finally, it keeps the idea of regular reviews—an ongoing cadence that helps tasks stay current—while pointing to existing routines for weekly, monthly, quarterly, and yearly check-ins.

For the task-management mechanics, the walkthrough installs the Obsidian community plugin “Checklist” and configures it to behave like a modern GTD-lite dashboard. By default, Checklist looks for tags that begin with a special keyword (it uses “Todo” as the default). Completed tasks can be hidden, and the checklist can group items by page or, as shown here, by tag. The plugin then populates a side panel “To Do List” with tasks organized into categories mirroring GTD’s structure: Next Action (the immediate step in a project), Waiting For (items blocked on someone else, used as a reminder to follow up), and Some Day Maybe (ideas without concrete plans).

Creating tasks is tag-driven. A user types a tag like “Todo next-action,” then adds a checkbox task under it (using a bullet with brackets or a command). Without the “Todo” prefix, items won’t appear in the checklist, even if other tags exist. The system also supports flexible expansion: it can be adapted to personal vs. work tasks by inserting additional tag layers (e.g., “Todo, work, next-action”), and it can collate tasks across different pages—so a thought captured mid-meeting still shows up in the correct checklist section.

Beyond GTD’s buckets, the workflow adds “context” tags such as “Computer” to distinguish what can be done in different situations. It also repurposes the same tagging pattern for agendas: “Todo, agenda, Jonathan” becomes a live list of discussion points that automatically appears when opening a person-specific note. The transcript even mentions using Dataview queries to pull agenda tasks into those person pages, keeping lists updated as new items are tagged.

The creator closes by contrasting alternatives: a Dataview-based task approach (tasks stored directly in notes rather than a side panel) and calendar blocking for time-sensitive work using Reclaim. The takeaway is less about terminology and more about choosing a system that reliably turns projects into clear next actions and keeps them visible when it matters.

Cornell Notes

The workflow modernizes GTD inside Obsidian by focusing on three phases—capture, process, and action—and then operationalizing the “next action” rule. Tasks are clarified into concrete steps and tagged so they surface in a Checklist side panel. The Checklist plugin uses tags starting with “Todo” to populate three GTD-style categories: Next Action, Waiting For, and Some Day Maybe. This tag-based setup lets tasks appear across pages, supports additional structure like work vs. personal, and enables context or agenda lists (e.g., “Todo, agenda, Jonathan”). The result is a practical, pseudo-GTD task dashboard that reduces vague task friction and keeps follow-ups and ideas from disappearing.

Why does separating capture from processing matter for getting things done?

The approach keeps GTD’s core discipline that capturing should happen as its own phase, before deciding what to do with the information. That separation prevents mental clutter: instead of holding thoughts in working memory while also deciding where they belong, the system collects them first, then processes later. The practical payoff is more brain capacity for actual work, because the “where does this go?” decision isn’t mixed into the “what do I do next?” moment.

How does the system enforce GTD’s “clarify the next action” principle?

It replaces vague tasks with specific, actionable steps by requiring tasks to be created under tags like “Todo next-action.” For example, rather than listing “Do taxes,” the workflow pushes toward a concrete next step that can be checked off. Because the checklist only displays items tagged with the special “Todo” keyword, tasks that aren’t properly clarified won’t appear in the actionable dashboard, which nudges better task granularity.

What are the three main task categories and what does each mean?

The Checklist plugin is configured to mirror GTD-style buckets. Next Action holds the immediate step of a project. Waiting For stores tasks blocked on someone else and acts as a reminder to follow up if the dependency drags. Some Day Maybe is for blue-sky ideas that are interesting but don’t have a concrete plan or next step right now.

How does the Checklist plugin decide which tasks to show?

Checklist displays tasks based on tags that start with its special keyword—“Todo” by default. If a checkbox item is tagged with something else but not with a “Todo …” tag, it won’t show up in the checklist side panel. The workflow also supports using tags on the fly as long as they begin with “Todo,” so users don’t need to predefine everything.

How can the same tagging system support context and agendas beyond GTD buckets?

Context tags like “Computer” let tasks be grouped by where they can be done, such as research work that requires a computer. For agendas, tags like “Todo, agenda, Jonathan” create a list of talking points tied to a specific person. When opening Jonathan’s note, a Dataview query can pull in tasks marked for that agenda, keeping the list current as new items are captured.

What alternatives are mentioned for task management and time-sensitive work?

Two alternatives are highlighted: a Dataview-based task approach where tasks live inside notes (rather than in a checklist side panel), and calendar blocking for time/date-sensitive tasks using Reclaim. The guidance is to pick the system that best matches how tasks are created and reviewed, not to chase a specific label or methodology name.

Review Questions

How does requiring a “Todo” tag change the quality of tasks compared with a free-form task list?
In what situations would a task belong in Waiting For instead of Next Action, and how does that affect follow-up behavior?
How could you design a tag structure that supports both work/personal separation and context (e.g., “Computer”) without making task entry too slow?

Key Points

1
Use GTD’s capture→process→action separation to prevent mental clutter before deciding what to do next.
2
Clarify tasks into concrete next actions; vague entries like “Do taxes” tend to stall because they’re too abstract.
3
Configure the Checklist plugin to show GTD-style buckets: Next Action, Waiting For, and Some Day Maybe.
4
Create tasks as checkbox items under tags that start with the plugin’s special “Todo” keyword; otherwise they won’t appear in the checklist.
5
Exploit tag layering to customize structure (e.g., work vs. personal) and to collate tasks across pages.
6
Add context tags (like “Computer”) and agenda tags (like “Todo, agenda, Jonathan”) to keep lists aligned with real-world situations.
7
For time-sensitive work, pair the task system with calendar blocking using Reclaim, and consider Dataview if you prefer tasks stored inside notes.

Highlights

Checklist only surfaces checkbox tasks tagged with the special “Todo” keyword, turning tagging into a quality-control step for next actions.

Next Action, Waiting For, and Some Day Maybe map cleanly onto project progress, dependencies, and blue-sky ideas—without forcing everything into one list.

Agenda tags like “Todo, agenda, Jonathan” can automatically populate person-specific notes, keeping conversation prep current.

Context tags (e.g., “Computer”) let the same task system support “where/when can I do this?” decisions, not just “what is it?”