Get AI summaries of any video or article — Sign up free
How to write atomic essays in Logseq thumbnail

How to write atomic essays 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

Atomic essays turn stored knowledge into output, reducing the risk of hoarding notes without transformation.

Briefing

Atomic essays are presented as a practical antidote to “collector’s fantasy” in personal knowledge management: capturing lots of inputs isn’t enough unless the system forces those ideas into publishable output. The core workflow centers on using Logseq not just to store notes, but to turn drafts into short, 200–250-word essays that can be refined, formatted, and published—so knowledge becomes something usable rather than a backlog.

The process begins with a writing schedule tied to the Ship 30 for 30 challenge: publish an atomic essay every workday for a month. After falling short of the full run (ending up with 18 essays), the focus shifts to the 18th essay—an intentionally meta topic about why atomic essays exist. In Logseq, the author creates a dedicated page (“ship 23 for 31”) and uses block-based outlining with indentation to collect raw ideas, partial drafts, and “departures” that can be revisited later. Ideas are scattered across the database, but indentation and tags make them quickly retrievable, even when the writing process is non-linear.

From there, the draft is built inside a single Logseq page using a “writing” tag and a right-sidebar workflow. A word-count plugin (triggered via a slash command) provides immediate feedback: the draft starts far below the target length (e.g., 57 words) and grows through iterative block additions. To avoid writing in a vacuum, the author pulls in relevant prior notes as block references—examples include reminders about writing for yourself, not quoting but making ideas personal, and using writing as reflection rather than performance. The system supports quick copy/paste of source blocks and rearranging threads as new angles appear.

Once the draft reaches a workable length, the author trims aggressively to remove content that drifts into criticism of the course rather than the intended theme. Grammarly is then used for language-level improvement, but only after the text is pasted in a clean format (copying without Markdown indentation artifacts). The essay is then moved into Figma for presentation: a template is duplicated, text is laid out into the design, and the final graphic is exported for posting.

Back in Logseq, the finished atomic essay is converted into a page (using a “turn into page” plugin) and linked to a daily journal entry via a “published” property. The author also maintains a structured “forest” system for Zettelkasten-style organization—projects and note types share properties for easy filtering. Finally, indentation under the “ship 23 for 31” tag creates a navigable archive of essays and associated assets (images, scraps). “Scraps” are treated as leftover fragments that remain searchable for future writing, enabling follow-up posts without losing earlier work. The result is a repeatable pipeline: capture → draft → refine → design → publish → archive, all driven by Logseq’s block and indentation mechanics.

Cornell Notes

Atomic essays are used as a forcing mechanism to convert stored knowledge into publishable output, countering the trap of hoarding notes without transforming them. In Logseq, ideas are collected on a dedicated project page using indentation and tags, then assembled into a draft with a writing tag and a word-count plugin to keep length near the 200–250-word target. Prior notes are pulled in as block references to generate angles and phrasing, while trimming removes off-topic material. After the draft is cleaned and improved with Grammarly, the text is formatted in Figma using a template, exported, and then converted back into a Logseq page with a “published” property and linked to the daily journal. Indentation and “scraps” tags keep both finals and fragments searchable for future essays.

Why does “collector’s fantasy” matter for knowledge management, and how do atomic essays address it?

Collector’s fantasy is the tendency to store lots of inputs (the “firehose of life”) without turning them into anything useful. Atomic essays counter that by requiring short, publishable output—about 200–250 words—so ideas must be processed into a coherent form. The workflow treats writing as the transformation step: capturing notes is only the beginning, while drafting and publishing forces integration into the author’s own thinking.

How does Logseq help keep an atomic essay near the target length during drafting?

A word-count plugin is used via a slash command (e.g., “/word count”), giving immediate feedback on the current draft length. The draft starts far below the target (around 57 words in the example) and grows through iterative block additions until it reaches a workable range. The author also treats the 200–250 word limit as a guideline, then trims to remove off-topic criticism and land around 218 words.

What role do tags, indentation, and the right sidebar play in the writing workflow?

Tags like “writing” create a focused set of related pages/blocks, and the right sidebar is used to open and browse those tagged items quickly. Indentation structures the project archive: essays are nested under a parent page (e.g., “ship 23 for 31”), making them easy to access later. Indentation also supports retrieval of “scraps” fragments via a dedicated hashtag, so leftover pieces remain searchable for future writing.

How are existing notes reused without turning the essay into a copy-paste exercise?

Relevant prior notes are brought in as block references or pasted snippets, then rewritten into the new draft’s voice and structure. The author uses stored writing-related ideas as “departures” (e.g., reminders about writing for yourself, not quoting, and writing as reflection). This keeps the essay grounded in prior thinking while still producing original output.

Why does the workflow move from Logseq to Grammarly and then to Figma?

Logseq is used for drafting and assembling ideas, but Grammarly handles language polish after the text is pasted cleanly (without Markdown indentation artifacts). Figma then handles visual layout: a template is duplicated (e.g., an “atomic essay 18” design), paragraphs are arranged into the design, and the result is exported as an image suitable for posting. This separates content creation from presentation formatting.

How does the system archive both finished essays and leftover fragments for future use?

After exporting the final design, the essay is converted into a Logseq page and linked to the daily journal using a “published” property. The author also uploads assets (like images) and organizes them under the project page. “Scraps” are treated as leftover fragments that remain searchable; they’re nested under a scraps hashtag so future essays can draw from earlier unfinished material.

Review Questions

  1. How does indentation under a project page change what can be found later compared with a flat list of notes?
  2. What steps in the workflow ensure the draft stays focused on the intended theme rather than drifting into tangential criticism?
  3. Why is it useful to treat “scraps” as searchable fragments instead of deleting them after an essay is published?

Key Points

  1. 1

    Atomic essays turn stored knowledge into output, reducing the risk of hoarding notes without transformation.

  2. 2

    Logseq’s block-based outlining and indentation make it easy to assemble drafts from scattered ideas and partial threads.

  3. 3

    A word-count plugin provides real-time length feedback so drafts can be trimmed toward the 200–250-word target.

  4. 4

    Reusing prior notes as block references helps generate angles while still producing original writing.

  5. 5

    Grammarly is most effective after copying text cleanly (without Markdown indentation artifacts).

  6. 6

    Figma templates standardize presentation, separating writing from visual layout and export.

  7. 7

    A “scraps” tagging approach preserves leftover fragments so future essays can reuse fragments instead of starting over.

Highlights

Atomic essays are framed as a practical cure for “collector’s fantasy,” forcing inputs into publishable, integrated output.
The workflow relies on immediate word-count feedback and iterative trimming to keep drafts on-theme and near the target length.
A two-stage pipeline—Logseq for drafting, Grammarly for language polish, Figma for layout—keeps content and design responsibilities separate.
Indentation plus tags create a navigable archive where both finals and “scraps” remain searchable for later writing.