Anchor Cards (Anchor from here on) is a spaced-repetition app that holds no cards of its own. The card of record is a Markdown file in your own GitHub repository. The app reads it to quiz you, and writes back only your review log and a snapshot of what you keep forgetting.
There is no screen for making cards inside the app. Cards are written and fixed by an AI agent on your PC or iPad (Claude, ChatGPT, and the like) — or by you, in your own editor.
The workflow it assumes
The AI agent is the teacher; you are the student.
- Tell an AI agent what you want to learn. It writes the cards as Markdown and puts them in GitHub
- Anchor reads the repository and quizzes you
- While reviewing, when something looks wrong, copy the card’s ID on the spot and hand it to the agent beside you
- The agent fixes it and opens a PR. You read that PR in the app’s Changes tab, rendered exactly as it will be quizzed
- Merge it if it reads right. It comes down on your next sync
Steps 3 to 5 are the heart of Anchor. In that loop, the app’s only job is reading.
The point of the loop is that you never leave the app to check a fix. Keep the agent beside you, read the result inside Anchor, and leave the screen open — it follows the next commit on its own (Changes).
How this differs from Anki
Anchor is not an Anki clone. Three differences in design.
The work of making cards moved out of the app
The main reason flashcard apps don’t stick is not the remembering — it is the labour of crafting good cards. Anchor moves that outside the app. Because the app has no path for creating or editing cards, the app structurally cannot break them.
One definition, written once (references, expanded at display time)
Copy the same definition onto ten cards and every change means ten edits, one of which always stays stale. In Anchor the text lives on one definition card, and question cards only reference it.
**Definition** [[stat-sd-def]]At quiz time the referenced card’s back is spliced in (the stored Markdown is never rewritten). Expansion goes one level only, to avoid reference cycles. See the card format.
**Definition** [[stat-sd-def]]. The bold word stays as a label, and the referenced card's back follows it. When the definition changes, there is exactly one card to edit.The cards are independent of the app
Your cards are ordinary Markdown in your own repository. They survive deleting the app, your Git history becomes your study history, and they open in an editor, on GitHub, or in any AI agent. No binary format like .apkg.
Terms
| Term | Meaning |
|---|---|
| vault | One GitHub repository holding your cards |
| card | One Markdown file in it (in v2, one file is one card) |
| deck | A group of cards. Reviewing starts from a deck |
id | A card’s permanent name. The only link between a card and its history |
| review log | data/reviews/YYYY-MM-DD.jsonl. Your grades — and the only record of your history |
| reference | [[id]], which splices another card’s back into this one |
| FSRS | The algorithm that decides when a card comes back (scheduling) |
What it deliberately does not do
- Create or edit cards in the app (as above: not having the path is the design)
- Run AI inference in the app (the app never sends anything to a model)
- Run a server of its own (the backend is your GitHub, and nothing else)
- Anki compatibility (it neither reads nor writes
.apkg) - Streaks, XP, confetti — making the streak itself the reward creates a reason to grade carelessly just to keep it