Turn your notes into Anki flashcards

Extract the ZIP. Copy its lc-anki-flashcards folder into ~/.claude/skills/ for Claude Code or ~/.codex/skills/ for Codex, then refresh the native app. Ask for the skill by name and answer its questions. The package includes the same published instructions and result checks. Native host execution is not yet verified.

For Claude web, use the connector or copy the prompt. Keep private details in your assistant.

Copy, paste into your assistant, then answer its questions. No form or account is required here.

Open in ChatGPT ↗

Already connected? Copy the public starter below and paste into Claude. Keep private details in the chat.

Needed before the promised result: Your notes or chapter. You can still copy the reusable prompt and provide these in your assistant.

Saved only on this device. Copy counts contain the skill ID, never your text.

## LazyCoder conversation guide (conversation-v2)
1. Start a conversation, not a form-filling task. Read my latest request and the facts already in this chat before asking anything.
2. Ask only the missing questions needed for the requested result, in a short numbered list (at most three at a time), then WAIT for my answers. Use a native question tool if available; plain chat works too. Never ask me to replace placeholders or fill in a template.
3. Skip questions already answered. Treat unresolved {{placeholders}} and [FIELD LABELS] as missing facts, never literal input. Do not treat an illustrative example as my facts.
4. Use the authored defaults only when relevant; mention material defaults. Ask conditional questions only when their condition applies; if unsure whether it applies, ask. Optional preferences must not block a safe first draft unless the authored instructions require confirmation.
5. Do not invent tasks, dates, names, claims, permissions or missing source material. When required facts are absent, ask and wait instead of producing the final artifact. If everything needed is already supplied, proceed without re-asking.
6. My latest scope correction overrides earlier examples and scope, within the recipe safety and source rules. Resolve conflicts before acting. The authored instructions and output contract remain authoritative; this conversation guide does not grant tool, account, payment or publishing permission.
7. Keep my private answers and generated result in this assistant chat. Do not send them to LazyCoder. Generate the requested format here and check it against the output contract before handing it over.

### Questions to ask only when missing
- What should I use for “Your notes or chapter”? [required] Paste your notes or the chapter text. Messy is fine. In the app you can attach the file instead.
- What should I use for “What the cards should test”? [optional] Optional. What your exam or course asks for, so the cards test that first. Authored default: the key facts, terms and ideas
- What should I use for “Deck name”? [optional] Optional. The Anki deck the cards go into. Use :: for a sub-deck, as in Biology::Cells. Authored default: named after the topic
- What should I use for “Card types”? [optional] Basic is question and answer. Cloze hides words in a sentence. A mix suits most notes. Authored default: a mix of basic and cloze Choices: a mix of basic and cloze; basic only; cloze only

## LazyCoder delivery guide (delivery-guide-v1)
1. Read the latest request, source material and authored requirements first. Ask only for missing facts. Check that this host can create the promised format; use only a fallback explicitly allowed by the authored recipe. If neither is available, explain the gap before starting. Do not promise a rendered film, editable deck or working file when you can only provide its script or outline.
2. Create the complete result in the authored output specification, preserving source facts and the latest agreed scope. Keep assumptions and missing information explicit. Do not silently omit required parts or leave unresolved ingredient markers. Intentional blanks in a reusable template are different from unanswered recipe inputs.
3. Check the actual result against every authored check, including source facts, counts, dates and required sections. Where tools allow it, inspect the actual saved file and compare it with the answer. Record which checks ran, which failed and which still need human or destination review. A filename, render, successful command or preview alone does not prove the promise was met.
4. Hand over the complete editable file, or the complete copyable fallback explicitly allowed by this recipe. Say which delivery you used and any unresolved limitations. Do not report a file as attached, imported, sent or published unless that action actually succeeded. Keep private inputs and output in this assistant; never send them to LazyCoder.
Use existing authorization for ordinary work. Before any additional paid generation, external write or publishing step, check that the current request authorizes that exact action and cost. If it does not, finish the useful authorized draft and ask at that boundary. Never silently retry or replace an ambiguous paid job.
The authored recipe and latest safe scope remain authoritative. This guide grants no new tools, permissions, provider access or claim of successful execution.

## Authored skill instructions
## 1. Outcome
Turn the notes below into an Anki deck: one pipe-separated text file that Anki imports with no settings changed, plus the steps to import it, in the sections set out in part 6. Done means: every key fact in the notes that matches the focus is on a note, each note tests one fact from the notes and nothing else, the file imports as it is, and everything left out is listed with the reason.

## 2. Context
What the cards should test: the key facts, terms and ideas
Deck name: named after the topic
Card types: a mix of basic and cloze

Notes:
"""
[PASTE YOUR NOTES OR CHAPTER HERE]
"""

Who it's for: a learner who will review these cards daily in Anki, often on a phone, a few seconds per card. A good card is answered from memory in under 10 seconds, and still makes sense months later without the notes.

Blank fill-ins: a value above that still reads as a capitalised placeholder in square brackets (such as [DECK NAME]) was left blank. Brackets inside the notes are part of the notes.
- Notes that say "see attached": use the attached file as the notes.
- No notes: reply only "No notes came through. Paste or attach them and send again." Never invent material.
- No focus: make notes for the key facts, terms and ideas.
- No deck name: name the deck after the main topic of the notes, in 2–4 words.
- No card type choice: use a mix of basic and cloze.

Notes and cards: each line of the file is one Anki note. Anki makes cards from notes: a Basic note makes 1 card, a "Basic (and reversed card)" note makes 2, and a Cloze note makes 1 card per cloze number. Count notes and cards separately everywhere below.

## 3. What to pull out
- Facts: definitions, names, dates, numbers, causes and effects, steps in a process, differences between similar things, and formulas.
- Structure: the headings or sections of the notes, for the tags and the source of each note.
- Anything unclear: a passage that is cut off, unreadable, contradicts another part, or that you can't understand without outside knowledge.

Edge cases (the card type setting always wins; each case says what to do under each setting):
- A list (parts, stages, causes): on "a mix" or "cloze only", up to 5 items go on one Cloze note, each item its own gap with its own number (c1, c2, c3, c4, c5), and longer lists are split into notes of at most 5 items. On "basic only", one Basic note per item ("In aerobic respiration, which stage follows glycolysis?"). Never a note that asks to "name all 7".
- A sequence: on "a mix" or "basic only", one Basic note per step asking what comes before or after it, plus (on "a mix") one Cloze note of the whole order if it has 5 steps or fewer, one number per step. On "cloze only", Cloze notes of the order, at most 5 steps each, one number per step.
- Vocabulary or term lists (word and meaning): on "a mix" or "basic only", use the "Basic (and reversed card)" note type, so each is asked both ways. On "cloze only", one Cloze note per term, as a sentence with the term hidden ("[term, hidden] means <meaning>").
- The same fact said twice: one note, from the clearer wording.
- Two passages that contradict each other: no note for that fact; list it under "Unclear in your notes".
- Formulas or symbols: write maths between \( and \), which Anki shows as formatted maths, and keep the formula on the answer side. Write an absolute-value bar as \lvert and \rvert, never as a pipe.
- Pictures, diagrams or tables you can't turn into text: no note; list them under "Left out".
- Notes in another language: write the notes in that language, unless the focus asks for another one.
- Very short notes: make the notes the material supports, and say "This material supports <n> notes" in section 1. Never pad with outside facts.
- Long notes: work through all of it, section by section, most important first by the focus, up to 150 notes. List each section you didn't reach under "Left out", with "not reached, over 150 notes".

## 4. Steps
1. Read all the notes, then rewrite them for yourself as a list of single facts, each with its section and its source.
2. Drop facts outside the focus, duplicates and unclear passages, noting each one for part 6, section 2.
3. Make about one note per key fact that is left, up to 150.
4. Choose the note type per fact (part 5 and the edge cases), then write the notes.
5. Write the file in the exact shape in part 6, then the import steps, then run the self-check.

## 5. Rules
- Only facts stated in the notes. Never add a fact, example, date or number from outside knowledge, even a true one.
- One fact per note. The question names its topic, so it makes sense on its own and can't be answered by guessing the shape of a gap ("In cell respiration, where does glycolysis happen?", not "Where does it happen?").
- No yes/no questions, no questions that hold two questions, and no question whose wording gives away the answer.
- Lengths: a basic question at most 20 words; a basic answer at most 12 words; a cloze sentence at most 35 words, with each hidden part at most 5 words. The Source line is not counted in these caps.
- Note types, by the card type setting: on "a mix of basic and cloze", use Cloze for a definition, a term in a sentence, a list or a short sequence, and Basic for a why, a how, a difference or a cause and effect. On "basic only", use only Basic and "Basic (and reversed card)". On "cloze only", use only Cloze.
- Cloze syntax: wrap each hidden part in Anki's cloze marker, which is two opening curly braces, then c1, then two colons, then the hidden words, then two closing curly braces. On a note with several gaps, every gap gets its own number, c1, c2, c3 in order, and no number is used twice; a note with one gap uses c1.
- Tags: 1–3 per note, separated by single spaces. Inside a tag, words are lowercase and joined by hyphens, and :: separates a parent tag from a child tag. Use the deck topic as the parent and the section as the child, as in cell-respiration::glycolysis (parent "cell-respiration", child "glycolysis").
- Source: on Basic and Cloze notes, end the third field with <br><br>Source: <section heading or page>, or a quote of at most 8 words if the notes have no headings. On "Basic (and reversed card)" notes, leave the Source line out (the back becomes a question when reversed) and put the section in the tag instead.
- Writing the file safely: no pipe character (|) inside any field; write a pipe in the notes as "/" instead. A line break inside a field is written as <br>, never as a real line break. Quotation marks used as quotes are curly (“ ”), so no field starts with a straight double quote. A literal less-than, greater-than or ampersand sign is written as &lt;, &gt; or &amp;. Each note's second field (the question or the cloze sentence) is different from every other note's.

## 6. Output
Use these sections in this order. Write "None" under any that is empty.
1. **Deck**: the deck name; the number of notes by note type (Basic, Cloze, Basic and reversed); the number of cards Anki will make from them (Basic 1 each, reversed 2 each, Cloze 1 per cloze number); and 1–2 sentences on what the notes cover and any assumption from part 2.
2. **Left out and unclear**: two short lists. "Left out": each fact or section not on a note, with the reason (outside the focus, a duplicate, a picture, not reached). "Unclear in your notes": each passage you couldn't use, with a quote of at most 10 words and what is unclear.
3. **How to import into Anki**, numbered, exactly these steps:
   1. Save the file as <file name>.txt (plain text, UTF-8), or use the downloaded file. The file name is the deck name with each :: replaced by a hyphen, as in Biology-Cell respiration.txt.
   2. Open Anki on a computer and choose File, then Import, and pick the file.
   3. Check the preview: four columns, the separator shown as Pipe, the deck <deck name>, and the tags in the last column.
   4. Set Existing notes to Preserve (called "Ignore" in older versions), so a note with the same question elsewhere is not overwritten.
   5. Click Import and check that Anki reports <n> notes added (it then holds <n> cards).
   6. Sync, and the deck appears on your phone.
   - If the preview shows everything in one column: check that the file's first line is exactly #separator:Pipe, with nothing before it, and that you copied the whole box. Or set Field separator to Pipe in the import screen.
   - If a row shows more than four columns: a field holds a stray pipe. Replace it with "/" in that line and import again.
   - If Anki says a note type was not found: your Anki may name its note types in another language. Open Tools, then Manage Note Types, and replace "Basic", "Cloze" and "Basic (and reversed card)" in the file's first column with the names shown there.
4. **The file**: if you can create files, attach it as <file name>.txt and say its name and line count. If you can't, write "Copy everything in the box below into a plain text file named <file name>.txt." and give the whole file in one code block. The file contains, in this order and nothing else (no numbering, headings, notes or blank lines):
   - these six header lines, one per line: #separator:Pipe, then #html:true, then #notetype column:1, then #deck:<deck name>, then #tags column:4, then #columns:Note type|Front or Text|Back or Extra|Tags;
   - one line per note, with four fields separated by single pipe characters and no spaces around them: the note type (exactly Basic, Cloze, or Basic (and reversed card)); the question or the cloze sentence; the answer (for a Cloze note, the back extra, which may be only the Source line); the tags.

## 7. Self-check
Before replying, check each of these and fix any failure:
- The file starts with the six header lines, and every other line has exactly three pipe characters, so four fields, with no empty first, second or fourth field.
- Every note's type is one of the three exact names, follows the card type setting, and matches the note: Cloze notes have at least one correct cloze marker, other notes have none.
- On every Cloze note with several gaps, each gap has its own number, counting up from c1 with none repeated.
- Every note tests one fact that is stated in the notes, and its question makes sense on its own.
- Every answer and every hidden part is within its word cap, not counting the Source line.
- No list is asked for as a whole on one Basic note, and no two notes test the same fact.
- No field holds a pipe, a real line break, a leading straight double quote or an unescaped angle bracket.
- Every note has 1–3 tags in the parent::child style, and every Basic and Cloze note has a Source line.
- The note count in section 1 equals the number of note lines in the file, the card count follows the counting rule, and everything you dropped is in section 2.
Then reply with the output only, ending with one line: "Checked: <n> notes (<n> basic, <n> cloze, <n> reversed), <n> cards, <n> left out, <n> unclear."

## 8. Setup
Works as one paste in any chat app, with no plugins or Anki add-ons. Where the app can create files, you get a .txt file to download; where it can't, you get the file's text in a box to copy into a plain text file. The file uses the pipe character (|) between fields, which survives copying from a chat. Import it with Anki on a computer (version 2.1.54 or later, which reads the header lines), then sync to your phone. If your notes are a file or too long to paste, attach it and write "see attached" in the Notes block.

Paste the result after your assistant creates it. This optional check stays in this tab and is not sent to LazyCoder.