Flashcard Generator

Create spaced-repetition flashcards from any content source -- articles, textbook chapters, video transcripts, lecture notes -- with Anki-compatible export and built-in review scheduling. This skill extracts key concepts, definitions, relationships, and procedures from your study materials and transforms them into well-structured flashcards following evidence-based principles like the minimum information rule and concept atomization.

Supported Platforms & Integrations

Platform	Integration Type	Features
Anki	APKG/CSV export	Generate Anki-compatible decks with tags, media refs, and scheduling metadata
Quizlet	CSV/TSV export	Export card sets in Quizlet-importable tab-separated format
Obsidian	Spaced Repetition plugin	Create cards as Obsidian notes compatible with the Spaced Repetition plugin
Notion	Markdown tables	Export flashcards as Notion database entries with front/back columns
RemNote	Markdown export	Generate rem-formatted cards compatible with RemNote import
Mochi	JSON export	Export cards in Mochi's native JSON format with deck organization

When to Use

• Textbook chapter review -- feed in a chapter's key sections and generate cards for all definitions, formulas, and key relationships
• Article distillation -- convert long-form articles into memorable flashcards capturing the core arguments and evidence
• Lecture note processing -- transform raw lecture notes into structured Q&A pairs for exam preparation
• Language vocabulary building -- create bilingual flashcards with example sentences, pronunciation notes, and usage context
• Certification exam prep -- generate practice cards from study guides aligned with specific certification objectives
• Meeting/presentation retention -- turn meeting notes or conference talk summaries into cards for long-term retention

Alternatives to consider:

• For image-occlusion cards (anatomy, diagrams), Anki's built-in image occlusion or AnkiDroid works better
• For pre-made shared decks, AnkiWeb and Quizlet have community-contributed decks for popular subjects
• For adaptive AI-driven review, apps like RemNote or Mochi handle scheduling natively with more sophistication

Quick Start

Copy
# flashcard-generator.yaml
skill:
  name: flashcard-generator
  description: Generate spaced-repetition flashcards from content
  config:
    default_export: anki          # anki, quizlet, obsidian, csv
    card_style: cloze_and_basic   # basic, cloze, cloze_and_basic
    max_cards_per_source: 30
    difficulty_levels: true       # tag cards as easy/medium/hard
    include_context: true         # add source context to card back
    storage_path: ~/.claude/flashcards/
    anki_deck_prefix: "Claude::"

Example interaction:

User: Generate flashcards from this: "Mitochondria are membrane-bound
      organelles found in the cytoplasm of eukaryotic cells. They
      generate most of the cell's ATP through oxidative phosphorylation.
      The inner membrane is folded into cristae, increasing surface area."

Assistant: Generated 4 flashcards:

  Card 1 (Basic):
  Q: What are mitochondria?
  A: Membrane-bound organelles found in the cytoplasm of eukaryotic
     cells that generate most of the cell's ATP.

  Card 2 (Basic):
  Q: Where are mitochondria located within the cell?
  A: In the cytoplasm of eukaryotic cells.

  Card 3 (Cloze):
  Mitochondria generate most of the cell's ATP through {{c1::oxidative
  phosphorylation}}.

  Card 4 (Basic):
  Q: What are cristae and what is their function?
  A: Folds in the mitochondrial inner membrane that increase surface
     area for ATP production.

  Export ready: anki_mitochondria_2026-03-15.apkg

Advanced Configuration

Platform-specific setup for Anki export:

Copy
anki:
  deck_name: "Biology::Cell Biology"
  note_type: "Basic (and reversed card)"
  tags_field: true
  media_path: ~/Documents/Anki/User 1/collection.media/
  include_reverse: false         # create reverse cards automatically
  cloze_note_type: "Cloze"
  scheduling:
    new_cards_per_day: 20
    review_cards_per_day: 100
    graduating_interval_days: 1

Full parameter reference:

Parameter	Type	Default	Description
default_export	string	anki	Export format: anki, quizlet, obsidian, csv, mochi, remnote
card_style	string	cloze_and_basic	Card types to generate: basic, cloze, or both
max_cards_per_source	number	30	Maximum cards generated from a single input
difficulty_levels	boolean	true	Tag each card with estimated difficulty
include_context	boolean	true	Add source paragraph to card back for reference
atomize	boolean	true	Break complex facts into single-concept cards
include_mnemonics	boolean	false	Generate mnemonic devices for difficult cards
language	string	en	Language for card generation
reverse_cards	boolean	false	Generate reverse (answer-to-question) cards
tag_prefix	string	""	Prefix for all auto-generated card tags
dedup_check	boolean	true	Check for duplicate cards in existing exports
storage_path	string	~/.claude/flashcards/	Local directory for card storage
review_schedule	string	sm2	Algorithm: sm2 (SuperMemo 2) or leitner

Core Concepts

Concept	Description
Minimum Information Principle	Each card should test exactly one piece of knowledge. Complex facts are split into multiple atomic cards for reliable recall
Cloze Deletion	A card format where key terms are blanked out within context sentences, preserving surrounding information as recall cues
Spaced Repetition	Review scheduling algorithm (SM-2) that increases intervals for well-known cards and decreases them for forgotten ones
Interference	When similar cards cause confusion. Prevented by adding distinguishing context and avoiding cards that differ by only one detail
Elaborative Encoding	Adding "why" and "how" context to card backs improves memory encoding depth beyond simple fact recall

  Flashcard Generation Pipeline
  ==============================

  [Source Content] --> [Key Concept Extraction]
         |                      |
         v                      v
  [Fact Atomization] --> [Card Type Selection]
         |                      |
         v                      v
  [Q&A Formulation] --> [Difficulty Tagging]
         |                      |
         v                      v
  [Dedup Check] ---------> [Export Formatting]
         |                      |
         v                      v
  [Local Storage] -------> [Anki/Quizlet File]

Workflow Examples

Scenario 1: Processing a textbook chapter

Input:  "Generate flashcards from Chapter 5 of my algorithms notes"
        [pastes 2000 words covering sorting algorithms]
Output: Generated 22 flashcards across 4 sub-topics:
        - Comparison sorts (8 cards): bubble, selection, insertion,
          merge, quick sort definitions and complexities
        - Non-comparison sorts (4 cards): counting, radix, bucket sort
        - Complexity analysis (6 cards): Big-O for each algorithm
        - Trade-offs (4 cards): when to use which sort and why
        Exported to: anki_sorting_algorithms_2026-03-15.apkg
        Tags: algorithms, sorting, cs-fundamentals

Scenario 2: Language vocabulary from an article

Input:  "Create Spanish vocabulary cards from this news article"
        [pastes Spanish article about climate change]
Output: Generated 15 vocabulary cards:
        Card 1: el calentamiento global --> global warming
                "El calentamiento global afecta a todos los paises."
        Card 2: la sequia --> drought
                "Las sequias son cada vez mas frecuentes."
        ...
        Export: quizlet_spanish_climate_vocab.tsv
        Difficulty distribution: 5 easy, 7 medium, 3 hard

Scenario 3: Certification exam preparation

Input:  "Generate AWS Solutions Architect cards from these notes on VPC"
        [pastes notes on VPC subnets, NACLs, security groups]
Output: Generated 18 flashcards:
        Card 1 (Cloze): A VPC spans {{c1::all Availability Zones}}
                in a region.
        Card 2 (Basic): Q: What is the difference between NACLs and
                Security Groups?
                A: NACLs are stateless and operate at the subnet level.
                Security Groups are stateful and operate at the
                instance level.
        ...
        Tags: aws, vpc, saa-c03, networking
        Export: anki_aws_vpc_2026-03-15.apkg

Best Practices

1. One fact per card -- resist the temptation to pack multiple facts into a single card. "What are the three branches of government?" should be three separate cards, each asking about one branch. This follows the minimum information principle.

2. Use cloze deletions for context-dependent facts -- when a fact only makes sense within its surrounding context, cloze deletion preserves that context while testing the specific knowledge.

3. Review the generated cards before importing -- automated generation occasionally produces cards that are too vague or test trivial details. A 2-minute review pass to delete or edit weak cards improves deck quality significantly.

4. Add personal connections to card backs -- after generating, annotate cards with your own examples or connections. "This reminds me of..." or "I saw this in..." dramatically improves retention through elaborative encoding.

5. Keep decks focused and well-tagged -- avoid a single massive deck. Organize by subject, chapter, or topic. Good tagging allows filtered review sessions focused on weak areas.

Common Issues

Issue: Too many cards generated from a dense source Solution: Set max_cards_per_source lower (15-20) and specify which concepts matter most. You can also use the difficulty_levels filter to generate only medium and hard cards, skipping facts you already know well. Quality over quantity -- 15 excellent cards beat 50 mediocre ones.

Issue: Cloze deletions test trivial words instead of key concepts Solution: Explicitly tell the generator which terms or concepts to focus on. Providing a list of target vocabulary or concepts constrains cloze generation to meaningful deletions rather than random word blanking.

Issue: Cards don't import correctly into Anki Solution: Verify the note type matches your Anki setup. The default export uses "Basic" and "Cloze" note types. If you use custom note types, specify the exact field names in the anki configuration section. Also ensure the APKG file is imported via File > Import in the Anki desktop application, not AnkiWeb.

Privacy & Data Handling

All source content, generated flashcards, and export files are stored locally in your storage_path directory (default: ~/.claude/flashcards/). Study materials you provide are processed in the conversation context and are not stored beyond the session unless explicitly saved. Exported APKG, CSV, and TSV files are written to your local filesystem. No content is shared with Anki, Quizlet, or any other platform -- exports are local files you import yourself. If your study materials contain proprietary or copyrighted content, the flashcards remain on your machine and are never uploaded to any service.