Generate optimal study flashcards in RemNote format from lecture PDFs and/or existing study notes. Use when the user asks to create flashcards, convert lecture materials to RemNote format, generate study cards from PDFs or notes, or refine existing RemNote questions. Handles both scenarios - PDF-only input, notes-only input, or combined PDF+notes where the PDF serves as the authoritative source for refinement and gap-filling.
Generate evidence-based, exam-focused flashcards in RemNote format from lecture materials and study notes. This skill applies cognitive science principles (minimum information principle, active recall) to create optimal flashcards for exam preparation.
Your flashcards must follow these evidence-based best practices:
Minimum Information Principle - One fact per card. This is the most important rule. Break complex concepts into atomic facts. NEVER ask "What are X and Y?" - make two separate cards.
Active Recall Over Recognition - Test understanding, not memorization. Avoid yes/no questions and multiple choice unless testing specific discriminations.
No Orphan Cards - Every card needs context. Don't create isolated facts that have no connection to broader concepts.
Quality Over Quantity - Better to have 30 excellent cards than 80 mediocre ones. Be selective about what's truly exam-relevant.
Preserve Existing Questions - When refining notes, keep the user's questions and improve them. Don't replace or omit their questions - they chose those topics for a reason.
Visual Formatting Enhances Retention - Use bold for key terms, inline code for function names/syntax, LaTeX for equations, and italic only with __text__ (never *text*).
Definition First - Always place the definition of a concept BEFORE any follow-up questions about it. If user's notes have questions in the "wrong" order (e.g., "How does X work?" before "What is X?"), reorder them so the definition comes first.
Overview Before Details - When there are multiple methods/algorithms for solving a problem (e.g., search algorithms, sorting methods, optimization techniques), ALWAYS add an overview question first that lists all methods, then individual questions for each:
Bold Keywords in Questions - ALWAYS make the main keyword/concept in each question bold:
sample(x)?" (Use of inline is the only exception)Concise Basic Answers - For basic Q&A cards (>>), keep answers SHORT. If an answer requires more than ~10 words, either:
Explain Mathematical Notation - When an answer contains mathematical symbols or complex notation, always explain what each symbol means within the same card. Convert to multi-line format (>>>) to include the notation alongside its definition:
- What is **Automated Algorithm Configuration (AAC)**? >>>
- Goal: find optimal config $\theta^* = \arg\max_{\theta \in \Theta}\, \mathbb{E}_{\pi \sim \mathcal{D}}\, p(A_\theta, \pi)$
- $\Theta$ — configuration space
- $\pi$ — problem instance, drawn from distribution $\mathcal{D}$
- $p(A_\theta, \pi)$ — performance of algorithm $A$ with config $\theta$ on instance $\pi$
You will receive input in one of the following formats:
Extract text from the PDF, identify main topics and exam-relevant concepts, generate comprehensive flashcard coverage. Focus on definitions, algorithms, properties, trade-offs, and computational complexity—skip trivial details like author birth dates or historical anecdotes unless exam-relevant.
The notes are structured hierarchically with bullets:
Your job:
Use the PDF as the authoritative source:
Important:
BE CONSERVATIVE. Quality matters far more than quantity.
Every card must justify its existence:
Avoid long cards:
First consolidate, then add carefully:
Choose the optimal card type for each concept:
>>)Use for: Conceptual questions, definitions, "what/why/when" questions
Format: Dash before question, space after >>
- What is the time complexity of QuickSort in the average case? >> $O(n \log n)$
<>)Use for: Bidirectional relationships, term ↔ definition
Format: Dash before term
- Binary Search Tree <> A tree data structure where left children are smaller and right children are larger than the parent node
{{...}})Use for: Fill-in-the-blank, embedded facts, definitions with key terms
Format: Dash before statement
- A {{Hash Table}}{({data structure})} provides $O(1)$ average-case lookup time using {{hashing}}.
With hints: Add {({hint})} immediately after cloze for disambiguation
>>>)Use for: Lists of related properties, characteristics (when order doesn't matter)
Format: Dash before question, exactly 2 spaces before each bullet point
- Properties of **Greedy Algorithms** >>>
- Make locally optimal choice
- Don't reconsider decisions
- May not find global optimum
- Often efficient
>>1.)Use for: Ordered sequences, algorithm steps, numbered procedures
CRITICAL: Use this for ALL algorithm steps, not multi-line (>>>). Order matters!
Format: Dash before question, exactly 2 spaces before each step
- Steps in **Merge Sort** >>1.
- Divide array into halves
- Recursively sort each half
- Merge sorted halves
>>A))Use sparingly: Only for discriminating between commonly confused concepts
Format: Dash before question, exactly 2 spaces before each option
- Which traversal visits BST nodes in ascending order? >>A)
- In-order traversal
- Pre-order traversal
- Post-order traversal
First nested bullet = correct answer (RemNote shuffles during practice)
Use rarely: Only if you're already using RemNote's concept/descriptor system
:> forward concept card;; forward descriptor card:: two-way concept cardApply consistently:
**text**) - Important terms, key concepts, algorithm names__text__) - Definitions, formal terminology (double underscore, no extra spaces)Inline code (backticks) - Function names, keywords, syntax (quickSort(), malloc(), class)$formula$) - Equations, complexity notation ($O(n^2)$, $\sum_{i=1}^{n} i$)IMPORTANT RemNote Syntax:
func(x) or %% won't work). Use either bold OR code, not both:
func(x) (inline code)func(x) (won't render correctly)__text__ (double underscore, NO extra spaces)__. Place a normal word first, then punctuation.
__term__ is important.__term__. _text_ (single underscore with 2 spaces before and after)*text* for italic - it doesn't work in RemNote!Example with full formatting:
- What is the **Bellman-Ford Algorithm** used for? >> Finding __shortest paths__ in graphs with **negative edge weights**, running in $O(V \cdot E)$ time
Preserve the hierarchical structure from input with proper indentation:
## Feature Selection
- What is **Feature Selection**? >> Identifying and keeping only the most informative features from a dataset
#### Filter Methods
- What is Information Gain filtering? >> Selects features maximizing $I(X; Y)$
- What is Frequency Filtering? >> Selects features based on occurrence counts
#### Wrapper Methods
- What are problems with forward selection? >>>
- Misses features strong in combination
- Computationally expensive
Indentation Rules:
##) - No indentation (left-aligned)####) - 4 spaces indentation (under H2)If PDF provided:
If notes provided:
If both:
For each exam-relevant concept:
Before outputting, verify each card:
Structure the output as valid RemNote import with proper indentation:
## Topic Name
- Question text >> Answer text
- Another question >>>
- Bullet point one
- Bullet point two
#### Subtopic
- Question text >> Answer text
- Another question >>>
- Bullet point one
- Bullet point two
#### Another Subtopic
- Question text >> Answer text
CRITICAL FORMATTING RULES:
__text__ for italic (NOT *text* - doesn't work in RemNote)__italic__, use a word — not punctuation (NOT __term__.)func(x) or %%)When a topic has multiple approaches/methods/algorithms, ALWAYS structure like this:
#### Feature Selection Methods
- What are the main types of **feature selection** methods? >>>
- Filter methods
- Wrapper methods
- Embedded methods
- What are **Filter** methods? >> Methods that evaluate features using __statistical properties__ independent of the model
- What are **Wrapper** methods? >> Methods that evaluate feature subsets based on model performance
- What are **Embedded** methods? >> Methods where feature selection occurs during model training
First the overview question listing all methods, then definition of each, then details.
- What is the time complexity of **Binary Search**? >> $O(\log n)$
- What is the space complexity of **Merge Sort**? >> $O(n)$
Note: Keep answers SHORT for basic Q&A cards.
- How does **Forward Selection** work? >>1.
- Start with empty set $F = \emptyset$
- Select best feature $X_r$
- Add if improves score
- Repeat until convergence
- What are properties of **Depth-First Search**? >>>
- Uses stack or recursion
- Not necessarily shortest path
- $O(V + E)$ time complexity
- Can detect cycles
- What is the trade-off between **Hash Tables** and **BSTs**? >>>
- Hash tables: $O(1)$ average lookup, no ordering
- BSTs: $O(\log n)$ lookup, maintains sorted order
- What does `malloc(size)` return in C? >> A `void*` pointer to allocated memory, or `NULL` if allocation fails
- What is **Dynamic Programming**? >> An __optimization technique__ that breaks problems into overlapping subproblems and stores solutions
- {{Dynamic Programming}}{({optimization technique})} breaks problems into overlapping subproblems
function(5)? >> 25")Input (from notes):
- Feature Selection
- What is Feature Selection?
- Filter Methods
- Information Gain Filtering
- How does Frequency Filtering work?
- What is Markov Blanket Filtering?
Output (with PDF context):
## Feature Selection
- What is **Feature Selection**? >> Identifying and keeping only the most informative features from a dataset
#### Filter Methods
- What are **Filter** methods in feature selection? >> Methods that evaluate features using __statistical properties__ independent of the model
- What are the main **filter** techniques? >>>
- Frequency Filtering
- Information Gain Filtering
- Markov Blanket Filtering
- How does **Frequency Filtering** work? >> Removes features with extreme occurrence frequencies
- How does **Information Gain** filtering work? >> Selects features maximizing $I(X; Y)$ between feature and target
- How does **Markov Blanket** filtering work? >> Selects features in the Markov blanket of the target variable, making it conditionally independent of all others
Rationale:
❌ Compound questions: "What are Grid Search's advantages and disadvantages?"
✅ Split into two cards: One for advantages, one for disadvantages
❌ Yes/no questions: "Is Binary Search faster than Linear Search?"
✅ Test understanding: "What is the time complexity advantage of Binary Search over Linear Search? >> $O(\log n)$ vs $O(n)$"
❌ Vague questions: "What about Quicksort?"
✅ Specific: "What is the worst-case time complexity of Quicksort? >> $O(n^2)$"
❌ Orphan cards: "What is a Markov blanket? >> ..."
✅ With context: "In feature selection, what is a Markov blanket? >> The minimal set of features that makes a feature conditionally independent of all others"
❌ Overlong lists: 10+ bullets in a multi-line answer
✅ Split: "Properties of X (1/2)" and "Properties of X (2/2)"
Before finalizing output:
>>1. (ordered), properties use >>> (unordered)__italic__, code, LaTeX__italic__ (there must be one word after the closing __)Deliver the final flashcards in one of these formats:
Option 1: Complete text file - Save as .txt file with all flashcards. Useful for reviewing, editing, or sharing before import to RemNote.
Option 2: Code block - Display all flashcards in a single markdown code block, ready to copy-paste into RemNote.
The user can specify which format they prefer, or you can choose whichever is most appropriate for the situation.
User instructions always take precedence over this skill's defaults. Examples:
For refinement requests (e.g., "fix the formatting on card 3", "make the SMAC answer shorter", "add bold to the keywords"):
You're ready! Extract, analyze, generate, and deliver optimal RemNote flashcards.