Get AI summaries of any video or article — Sign up free
Task management, time-blocking and productive habits with Josh Duffney (Logseq & Dendron) thumbnail

Task management, time-blocking and productive habits with Josh Duffney (Logseq & Dendron)

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

Dendron’s namespace-first model mirrors software navigation (packages/functions), while Logseq’s journal-first model relies on links and collections to create structure later.

Briefing

Task management and knowledge work land in two different places depending on how a person structures hierarchy: Josh Duffney’s approach in Dendron leans “hierarchy first” (namespaces that behave like software packages), while his Logseq workflow keeps a “journal-first” fluid graph and then layers time-blocking, staging, and retrieval on top. The practical takeaway is that both systems can work—but the mental model behind them determines whether planning stays stable as responsibilities grow.

Duffney draws a sharp contrast between Dendron and Logseq. In Dendron, notes live inside an intentional namespace tree (e.g., area.discipline → folder-like levels), with tab completion and a refactor-style hierarchy that can rename and reorganize without breaking the overall structure. That mirrors how developers browse code: packages contain functions, and knowledge is navigated the same way. He describes this as a systems-driven design shaped by years managing computer systems—he doesn’t just write a note about something; he creates a place for it, then lets the hierarchy evolve as understanding deepens.

Logseq, by comparison, is presented as more flexible and “gardening”-oriented: journal notes act like scratch pads, then links and collections assemble them into usable views. Duffney emphasizes that this fluidity helps him keep momentum and avoid the friction that can come from rigid upfront structuring. He also notes a practical tool-lifecycle habit: he tends to trial tools for about six months, then experiments again once the system “explodes” into unmanageable complexity.

On task management, Duffney’s core method is time blocking with time boxing across three daily realms: personal life (husband/father and health), a creative manuscript project, and full-time work (shifting from Microsoft technical writing to a cloud advocacy role). He uses weekly staging (“week ahead”) to place tasks onto future days without planning every detail the night before. Then, each morning, he plans at the start of work—staged tasks become the day’s execution plan, while deadlines and projects anchor the schedule.

For deeper control, he uses Logseq templates and varying resolution: a weekly snapshot for overview, then templates for morning and afternoon grids when interruptions or encroachment require hour-by-hour precision. He also follows a “maker vs manager” split (deep work vs meetings/shallow tasks) and uses session timers to block distractions like Twitter and Outlook during maker blocks. A shutdown ritual—capturing loops and staging tomorrow’s work—functions as a daily off-ramp.

Duffney’s knowledge-management philosophy ties into feedback mechanisms: note systems can become “black holes,” so he relies on reverse-chronological retrieval, tags for reliable re-entry, and a Logseq Random Note plugin to surface neglected pages for cleanup. He also discusses the PARA method (projects, areas, resources, archive) as a way to separate life domains digitally and prevent overwhelm—especially by archiving completed creative work so it doesn’t clutter active decision-making.

Finally, the conversation highlights an integration challenge: automating task handoffs across tools requires workflow orchestration and shared standards (APIs, formats, and clear handover steps), not just early automation. Duffney’s approach keeps the “process” legible first, then considers automation once the handoff logic is clear.

Cornell Notes

Josh Duffney contrasts Dendron and Logseq through their underlying hierarchy models. Dendron is “hierarchy first,” using namespaces like software packages (with tab completion and refactor-style renaming) so knowledge is navigated intentionally. Logseq is “journal-first,” where notes start as scratch pads and links/collections create structure later, supporting a more fluid graph. For task management, Duffney time-blocks and time-boxes across personal, creative, and work realms, staging tasks in a weekly view and planning execution each morning. He reinforces the system with feedback loops: reverse-chronological retrieval, tags for reliable re-entry, and a Random Note plugin to prevent knowledge from becoming a black hole.

Why does Duffney call Dendron “hierarchy first,” and what does that look like in practice?

Dendron organizes notes as an intentional namespace tree, similar to how developers browse code packages and functions. Duffney describes a pattern like area.discipline (where the dot-separated levels act like folders/namespaces), then uses tab completion to expand terms (e.g., searching for “polymorphism” under a programming namespace). He also highlights refactoring: renaming a namespace (e.g., “r vs code” to “r vs code shortcuts”) can update the whole structure so the hierarchy stays consistent as his understanding evolves.

How does Logseq’s “journal-first” approach change the way tasks and knowledge are structured?

In Logseq, Duffney treats journal notes as scratch pads. Instead of forcing a rigid hierarchy at creation time, he relies on links and collections to compile journal entries into different views later. This “gardening” model keeps the workflow fluid: daily notes can be reorganized into collections without requiring every note to be placed into a perfect namespace immediately.

What does Duffney mean by staging tasks for his future self?

He uses a weekly planning note (“week ahead”) to place tasks onto future dates without fully planning every day in advance. For example, tasks can be marked with the day they should be executed (e.g., a rough draft due on a specific date). Then, each morning at the start of work, he molds the day from what’s already staged—so he avoids night-before obsession while still ensuring tomorrow’s execution is ready.

How does Duffney use time blocking differently depending on the day’s pressure?

He uses two layers of resolution. Most days, he plans at a higher level (a few deep-work blocks and shallow tasks). When interruptions or time theft increase, he switches to more granular templates like a morning grid and afternoon grid, scheduling hour-by-hour to protect deep work. He also uses session timers (digital Pomodoro-style blocks) to reduce distractions during maker time.

What feedback mechanisms keep Duffney’s note system from becoming a “black hole”?

He emphasizes retrieval and cleanup loops. Notes are revisited in reverse chronological order, tags are used to aggregate lists and enable reliable re-entry (e.g., reading lists), and a Random Note plugin helps surface older entries for cleanup. The goal is to ensure notes remain usable and don’t just accumulate.

How does the PARA method show up in Duffney’s workflow?

PARA provides digital separation: projects, areas of responsibility, resources, and an archive. Duffney uses archive as a mental “box on a shelf” to prevent overwhelm from multiple active creative manuscripts. He also connects PARA to practical note-taking: notes should have tangible reuse value rather than becoming hoarded collections.

Review Questions

  1. How do Dendron namespaces and refactoring change the way knowledge is reorganized compared with Logseq’s link-and-collection approach?
  2. Describe Duffney’s daily planning cycle from weekly staging to morning execution. What problem does it solve?
  3. What specific mechanisms does Duffney use to prevent notes from becoming hard to retrieve or overwhelming to manage?

Key Points

  1. 1

    Dendron’s namespace-first model mirrors software navigation (packages/functions), while Logseq’s journal-first model relies on links and collections to create structure later.

  2. 2

    Duffney time-blocks and time-boxes across three realms—personal, creative manuscript work, and full-time job—so one domain doesn’t bleed into the others.

  3. 3

    Weekly staging (“week ahead”) lets tasks sit for future execution without night-before overplanning, and daily planning happens at the start of work.

  4. 4

    When interruptions rise, Duffney increases planning resolution using morning/afternoon grids and session timers to protect deep work.

  5. 5

    A shutdown ritual (capturing loops and staging tomorrow’s work) acts as a daily off-ramp that supports follow-through.

  6. 6

    To avoid note hoarding and black-hole behavior, Duffney uses retrieval loops (reverse-chronological views), tags for aggregation, and a Random Note plugin for cleanup.

  7. 7

    Cross-tool automation should follow a mapped handoff workflow and shared standards (e.g., API-like formats), not be attempted before the process is clear.

Highlights

Dendron treats knowledge like code: namespaces behave like packages, and refactoring can reorganize the hierarchy while keeping the structure coherent.
Logseq keeps daily notes as scratch pads, then uses links/collections to assemble meaning after the fact—supporting a more fluid workflow.
Duffney’s planning system separates staging (weekly) from execution (morning), reducing obsession while still ensuring tasks land on the right day.
Session timers plus a maker/manager split help Duffney protect deep work by blocking distractions during execution windows.
A Random Note plugin functions as a practical cleanup engine, surfacing neglected pages so the system stays usable.

Mentioned