The Flashcards Skill: Make Great Cards With Claude Code and Codex

You ask the model how something works, read the explanation, and want to keep it. One line turns that moment into cards:

That is the whole loop. You learn something in the conversation you are already having, then /flashcards drafts proper cards and writes them into Space. They sync to your phone before you close the terminal.

Any AI can spit out a hundred flashcards in a few seconds. The problem is that most of them are bad: they test recognition instead of recall, cram three facts onto one card, or answer with a list you will never reproduce from memory. Generation was never the hard part. Quality is. Our Space CLI post made the case for “bring your own AI”. This skill adds the part the raw pipe was missing: it already knows what a good card looks like.

What the skill does

It is two things in one file. First, a compact set of rules for what makes a card worth reviewing, drawn from the spaced-repetition research (Make It Stick, Fluent Forever, How We Learn). Second, the handful of Space CLI commands it is allowed to run, so it can create the deck, group the cards, and write them without you touching space card create yourself.

It runs in Claude Code and in OpenAI Codex. Same file, both tools.

Prerequisites

Install the skill

Both Claude Code and Codex read skills as a folder with a single SKILL.md inside. Save this file:

---
name: flashcards
description: Create high-quality spaced-repetition flashcards and save them to Space via the CLI. Triggers on requests to make flashcards or a deck about a topic or source.
argument-hint: [topic or source]
allowed-tools: Bash(space *)
---

# Create flashcards

Goal: cards that force active recall and build lasting understanding,
not cards that just store facts.

Input: $ARGUMENTS is the topic, source (a book, a note, a text), or
keywords to build cards from.

## What makes a good card

1. Force active recall. A card is a self-test, not a reading note. Ask
   open questions where the answer must be reconstructed, not recognized.
2. One card, one fact. Each card asks for exactly one thing. Keep it as
   short as possible without losing clarity.
3. One unambiguous answer. The question must have a single correct answer.
4. Understanding before memorizing. Cover fundamentals first, then build
   up. Aim for connected knowledge, not isolated facts.
5. Elaborate and connect. Link the new fact to something known, a concrete
   image, a vivid example. Extra retrieval paths make recall easier.
6. Integrate context into the question. Good: "What does ATP mean in
   biochemistry?" Bad: "[Biochemistry] What does ATP mean?"
7. Break up lists. Turn an enumeration into single questions, or use
   overlapping cards (A then B, B then C).
8. Avoid confusion. Give similar concepts distinguishing context.
9. Group related cards. Build from a base concept toward combinations.
10. Ask both directions. A to B and B to A strengthens retention.
11. Timestamp perishable facts. Add "as of [year]" to current numbers.

Avoid: trivial facts, answers longer than three or four lines, ambiguous
questions, opinions instead of facts, lists as an answer.

## Format

Space uses a Q:/A: format. Never use cloze deletions ({{c1::...}}).
Never use em dashes or en dashes; use a comma, colon, or two sentences.

Q: [Precise question with context built in]
A: [Short, clear answer]

## Save the cards in Space

Use the Space CLI. It writes directly to the local database that syncs
with the app.

space deck create "Deck name"            # returns a deck id
space group create <DECK-ID> --name "Group name"
space card create <DECK-ID> [--group <GROUP-ID>] \
  --front "Question?" --back "Answer."

## Quality check

Before saving each card, confirm: one fact only, one correct answer,
forces recall not recognition, answer is short, context is built into
the question, similar cards stay distinct.

Where it goes depends on the tool:

The name and description fields are all both tools need. The argument-hint and allowed-tools lines are Claude Code extras and Codex ignores them. In Codex, shell access to space runs through your approval and sandbox settings, so allow it when prompted.

What it runs under the hood

There is no magic. The skill turns its draft into the same CLI calls you could type by hand, so nothing is hidden and you can edit anything afterwards:

space deck create "TLS Handshake"
space group create a1b2 --name "Key exchange"
space card create a1b2 --group c3d4 \
  --front "Why does TLS switch to symmetric encryption after the handshake?" \
  --back "Asymmetric crypto sets up a shared key but is slow. Symmetric encryption is far faster for the actual traffic."

The real difference is the cards themselves. The skill writes the question on the left, not the one on the right:

The left column forces you to reconstruct the answer. The right column you can guess or recognize, which feels like learning but is not.

Sync everywhere

Cards the skill creates show up on your phone, tablet, and desktop. PowerSync pushes every CLI write to the server and from there to your other devices. No manual sync, no separate login in the CLI.

Why this works

Three well-documented effects do the work: retrieval practice beats rereading by a wide margin (Roediger and Karpicke, 2006), the generation effect anchors knowledge you produce yourself, and elaboration builds extra retrieval paths when new knowledge links to the old. The skill bakes those into every card so you do not have to remember them each time.

If you want the full reasoning behind the rules, including which ones matter most, read How to write flashcards that stick.

Ready? Install the app and the CLI, drop the SKILL.md into ~/.claude/skills/flashcards/ or ~/.agents/skills/flashcards/, and run /flashcards <your topic>. Your data stays yours, exports as JSON or CSV whenever you want, and syncs across every device.