Skip to content

IR Flow Reading Extracting and Clozing

Jump to bottom
hugomarins edited this page May 2, 2026 · 7 revisions

IR Flow: Reading, Extracting, and Clozing

This page describes the Incremental Reading workflow supported by the plugin — a SuperMemo-inspired loop for breaking down large documents into smaller, reviewable pieces and converting key passages into flashcards, all without leaving the editor.

The three commands that drive this workflow are:

Command Shortcut Action
Create Extract Alt+X / Alt+Shift+X Pulls selected text into a new child Rem and initializes it as an Incremental Rem
Create Cloze Alt+Z Creates a standalone cloze-deletion child Rem from the selected text
Create Cloze with Priority Alt+Shift+Z Same as above, then opens the Light Priority popup to set a Card Priority
PDF Control Panel Command Palette → PDF Control Panel Central hub for splitting a PDF into chapters/sections, assigning page ranges, and tracking reading progress

Step 0: Splitting — Breaking Complexity Before Extracting

Before you extract sentences or cloze individual words, there is a more fundamental step: breaking the material itself into manageable pieces. This is what separates sustainable incremental reading from the exhausting attempt to process a 300-page book in one sitting.

The core principle is simple: you cannot review what you cannot schedule. A single Incremental Rem pointing at an entire book will appear in your queue as one monolithic item. You will open it, skim a few pages, feel overwhelmed, and hit "Next" — making no real progress. The solution is to split the material into units small enough to meaningfully review in a single session.

The Splitting Cascade

Incremental Reading works as a top-down cascade of decreasing granularity:

Book (folder rem)
  └── Chapter 1                ← Incremental Rem, pages 1–50
        └── Key passage A      ← Extract (Alt+X): a paragraph worth returning to
              └── "X is Y"     ← Cloze (Alt+Z): the atomic testable fact
        └── Key passage B
  └── Chapter 2
  └── Chapter 3

At each level, you only go deeper on the material that deserves it. Most of a chapter may be skipped entirely on the first pass; a few dense paragraphs will generate multiple extracts; a handful of those will generate clozes. The queue handles each piece on its own schedule.

You Do Not Need to Get It Right on the First Pass

This is the most important thing to internalize: the split does not need to be perfect. You do not need to identify every chapter, section, and sub-section before you start reading. The process is iterative and self-correcting:

  • Start with a rough split (e.g., one Rem per chapter, even without correct page ranges).
  • As you read Chapter 1 and encounter a natural section break, split it into two children on the spot.
  • The next time Chapter 1's sub-sections come up in the queue, one of them may itself be subdivided further.
  • After a few passes, the hierarchy naturally reflects the structure of the material — not because you planned it, but because the queue kept bringing you back to what mattered.

The PDF Control Panel's coverage badge (visible on parent rows) helps you see at a glance how much of a chapter has already been sub-divided, so you always know where more granularity is needed.

How to Split a Long PDF

For a full, step-by-step setup guide see the PDF Incremental Reading Workflow page. In summary:

  1. Create a parent rem for the book and add the PDF as its source.
  2. Create one child rem per chapter (or per rough section if the book has no clear chapters). Do not worry about exact page boundaries yet.
  3. Tag the first chapter as Incremental (Alt+X) and add the PDF as its source. Use Copy & Paste Rem Sources (Ctrl+Shift+F1 then Alt+Shift+V) to propagate the PDF to all other chapters without repetition.
  4. Open the PDF Control Panel (Command Palette → PDF Control Panel) on any chapter to assign page ranges to all of them in one place.
  5. Start reading. When Chapter 1 appears in the queue, read until a natural break, then split by extracting the sub-section as a child rem with its own page range. Dismiss or schedule Chapter 1 for later.

Tip

You do not need to split every chapter before you start. Queue only the chapters you are ready to engage with now and leave the rest at low priority. The queue will bring them forward when their turn comes.

Splitting Text-Based Material (Articles, Web Pages, Notes)

Not all incremental reading involves PDFs. For articles pasted into RemNote, long notes, or imported web content, the same cascade applies — but splitting is even simpler:

  • Use Alt+X on a paragraph or section heading to extract it as a child Incremental Rem.
  • The parent (the full article) becomes a coarse-grained item you will eventually dismiss once all its important sub-sections have been extracted.
  • There is no need to pre-structure the document before you start. One pass through the material with Alt+X creates the structure organically.

Tips for Sustainable Splitting

  • Err on the side of larger chunks first. It is always easier to split a large rem into two than to merge two overly-granular ones. Start with chapters; refine into sections only when the chapter proves too long to read in one session.
  • Use the Priority System to sequence your splits. Assign the most important chapter the highest priority. You will naturally split it more finely because you encounter it more often.
  • A rem that is "too long" is a signal, not a problem. When you open a rem in the queue and feel you cannot make progress in one session, that is the cue to split it — right there, immediately, before hitting Next. Create two or three child rems from the headings you see, schedule the first, and dismiss the parent.
  • The parent rem is not wasted after splitting. After its children are created and queued, tag the parent with #remove-from-queue to suppress it from the queue. Its children are now doing the work.

Create Extract (Alt+X / Alt+Shift+X)

When reading a long Incremental Rem (a chapter, article, or section), you isolate the most important passage and turn it into its own Incremental Rem for deeper review later.

How it works:

  1. Select the text you want to extract.
  2. Press Alt+X (or Alt+Shift+X to set a specific priority immediately).
  3. The plugin:
    • Creates a child Rem containing the selected text.
    • Highlights the original selection in blue in the parent Rem and inserts a reference pin (↗) next to it — clicking the pin navigates to the new child.
    • Adds a back-reference pin at the end of the child Rem pointing back to the parent, maintaining full traceability.
    • If the parent Rem was itself extracted from a PDF highlight, the child inherits a direct pin to the original PDF source as well.
    • Tags the parent Rem with #remove-from-queue so its original queue slot is suppressed — the children take over.
    • Initializes the new Rem as an Incremental Rem (with Alt+X: inherited or default priority; with Alt+Shift+X: opens the Priority popup).

This process is called "shredding" a document: you pass through it incrementally, pulling out what matters and leaving the rest behind.

Extract Selection Demo

Create Cloze (Alt+Z / Alt+Shift+Z)

While reading, you often encounter a key term, definition, or fact that you want to memorize — not just re-read. Alt+Z converts the selected text into a cloze deletion flashcard in the SuperMemo style.

Alt+Shift+Z — Create Cloze with Priority: Identical to Alt+Z, but immediately opens the Light Priority popup after creating the cloze child Rem so you can set its Card Priority in one step. E.g. The first occasion you face an extract (short sentence), you make a cloze out of the most important information and attribute a priority of 10; the second occasion, you make another cloze out of the secondary information and attribute a priority of 20. In the third and last occasion before dismissing the IncRem, you make the last cloze out of the less important information and attribute a priority of 30.

What happens

  1. Select the word or phrase to test yourself on.
  2. Press Alt+Z.
  3. The plugin:
    • Creates a child Rem as a standalone cloze flashcard.
    • The child's text contains the full content of the parent Rem (front and back, if it is a flashcard), with the card delimiter replaced by a directional arrow (⇒, ⇐, or ⇔ — derived from the card's practice direction).
    • Any existing cloze marks in the parent's text are stripped from the child copy and re-marked with yellow highlight + red font, so you can see where other holes existed without them interfering with the new cloze.
    • The selected text is marked as the new cloze deletion in the child.
    • If the parent is a Concept rem, the front portion of the child is rendered in bold. If it is a Descriptor, it is rendered in italic — matching RemNote's native UI conventions.
    • A back-reference pin to the parent Rem is appended at the end of the child's text.
    • The parent's selection is marked with yellow highlight + red font to signal that this passage has already been cloze-extracted.
    • The parent Rem is tagged with #remove-from-queue.
    • The child Rem receives a cloze-extract tag, which renders a small violet ↑ badge in the queue (hover for a tooltip) so you can always identify cards that originated from this workflow.

Visual result in the child Rem

The child inherits the full context. If the parent says:

Navigation systems :: GPS cannot be relied upon alone

and you select "GPS", the child becomes:

Navigation systems ⇒ [GPS] cannot be relied upon alone ↗

where [GPS] is the cloze deletion and ↗ is the back-reference pin.

Comparing Alt+Z (SuperMemo-style) with Native RemNote Clozes

RemNote has its own built-in cloze system — marking text with {curly braces} or via the cloze toolbar. The two approaches have distinct advantages:

Native RemNote Clozes

  • Spoiler protection: RemNote's scheduler automatically buries (hides for ~1 hour) other cloze cards from the same Rem after one is reviewed. This prevents you from accidentally getting spoiled on a related answer you haven't been tested on yet.
  • Compact: Multiple clozes live inside a single Rem. No extra Rems are created.
  • Simpler workflow: Just highlight and mark — no child Rem is generated.
  • Best for: Dense material where multiple facts in a single sentence all need to be tested, and you trust RemNote's bury logic to prevent spoilers.

Alt+Z SuperMemo-style Clozes

  • Standalone Rem: Each cloze becomes its own independent Rem in the knowledge base. This means it has its own scheduling history, its own priority, and can be edited, simplified, or reorganized entirely independently of the parent.
  • Atomic by design: Because the child is a separate Rem, you are naturally encouraged to make each card as atomic as possible. Over time, you can simplify the child's wording — removing irrelevant context — making it faster to review and easier to memorize.
  • Incrementally refineable: The child can itself be extracted further or restructured. Native clozes inside a parent Rem cannot be individually promoted or separated.
  • Full context preserved: The child always carries the full front-and-back of the parent, so you never lose the context in which you learned the fact.
  • Best for: Key terms, definitions, and facts you want to make truly independent, atomic, and long-term durable — especially during the first read of a new document.

Summary

Native RemNote Cloze Alt+Z SuperMemo-style Cloze
Spoiler protection (bury) Yes No (each card is independent)
Standalone Rem No Yes
Individually schedulable No Yes
Can be simplified over time No Yes
Atomic card design Encouraged by discipline Structurally enforced
Number of Rems created 0 (inline) 1 per cloze
Back-reference to source No Yes (pin appended)
Visual queue badge No Yes (violet ↑ badge)

The two approaches are complementary. Use native clozes for quick, spoiler-safe multi-cloze sentences. Use Alt+Z when a concept is important enough to deserve its own card and its own long-term refinement path.

User's Manual

Clone this wiki locally