Upload folder using huggingface_hub

NOTES.md

@@ -0,0 +1,367 @@
+by [Luise](https://www.lesswrong.com/users/luise?from=post_header)
+
+8th Jul 2025
+
+32 min read
+
+[46](https://www.lesswrong.com/posts/7Q7DPSk4iGFJd8DRk/#comments)# 132
+
+I can't count how many times I've heard variations on "I used Anki too for a while, but I got out of the habit." No one ever sticks with Anki. In my opinion, this is because no one knows how to use it correctly. In this guide, I will lay out my method of circumventing the canonical Anki death spiral, plus much advice for avoiding memorization mistakes, increasing retention, and more, based on my five years' experience using Anki.
+
+This guide comes in four parts, with the most important stuff in Parts I & II and more advanced tips in Parts III & IV. **If you only have limited time/interest, only read Part I; it's most of the value of this guide!**
+
+Roadmap to the Guide
+
+This guide's structure is inspired by how someone new to Anki might want to read it:
+
+**Part I** contains day 1 advice for using Anki in a way that prevents the Anki death spiral. (But it is not a general intro to Anki; I leave that to other resources.)
+
+**Part II** aims to save you from common mistakes, especially ones that waste effort without increasing your recall, for day 3 of using Anki.
+
+**Part III** dives into more detailed card design issues, including for difficult and interrelated "information thickets", for week 3 of using Anki.
+
+**Part IV** contains even more & obscure pro tips for Anki, for week 5 of using Anki.
+
+But Anki users of all experience levels have found this guide useful by skimming & skipping between the parts that were new/interesting to them!
+
+# My Most Important Advice in Four Bullets
+
+1. **20 cards a day —** Having too many cards and staggering review buildups is the main reason why no one ever sticks with Anki. Setting your review count to 20 daily (in deck settings) is *the single most important thing* you can do to stick with Anki long-term.
+2. **Atomic cards** — Studying long cards is *gruelling*. Studying cards with 1-5 words on the back is *fun*. Make every card *as short as humanly possible* (even 1 word!) by breaking things up into many cards.
+3. **No to-be-learned information in the prompt** — You're only memorizing the *back* of cards. Don't put any to-be-learned information on the *front*. If recalling the back of a card is not useful without knowing crucial info given in the prompt, the card is not useful.
+4. **Bland prompts —** Make prompts as absolutely non-descript and standardized as possible. Otherwise, you will learn a dumb pattern like *prompt with fancy words -> recall X,* or *funny typesetting -> recall X,* and not be able to recall X outside Anki at all.
+
+# I. Anki Day 1: Or, No One Ever Sticks With Anki
+
+I cannot emphasize enough how often I've met people who want to use Anki in principle, but don't seem to be able to create a long-term habit. (This was also me for most of my five years on-and-off using it.) No one ever sticks with Anki. I believe I know the two reasons for this:
+
+1. Too many cards
+2. Too long cards
+
+Solving these two problems is probably 90% of the value of this guide. Let's get into it.
+
+## Too many cards
+
+People usually enthusiastically start by revising like 50+ new cards in a day. Then the enthusiasm wears off, and you skip a day. Next day, there are like 200 revisions due. Then you are discouraged, skip that day as well, along with the next seven, until you have about a million cards due and see no way of ever getting through them. This is the canonical Anki death spiral.
+
+Instead, set a daily limit on card reviews of 10 or 20. **This is perhaps my most important piece of advice.** Really, do it. Yes, you will learn fewer cards. But the alternative (in my experience) is not using Anki long-term **at all**. If you set your daily review limit to 20, even if you skip a day (or ten), Anki will only show you 20 cards due after. This prevents procrastination spirals. You are always capable of doing 20 reviews after all, no matter the day.
+
+If you truly feel like doing more on a given day, you can always increase your limit for that day by another 20 (long-tap the deck > Custom Study > Modify Today's Review Card Limit). You can do this as often as you like, which, in any case, is more fun than doing one monster heap of reviews. (But doing it too much on one day is probably not sensible, as you won't be able to review all those new cards within your normal daily limit going forward.)
+
+You can set your daily review limit by long-tapping the deck > Deck options > "Daily Limits" at the top. If you set the daily review limit to 20, you should set the daily limit of *new* cards to 2, since otherwise your reviews won't keep pace with your adding new cards. If you set the review limit to 10, you should set the new card limit to 1, etc.<sup><span><span></span><a href="https://www.lesswrong.com/posts/7Q7DPSk4iGFJd8DRk/#fnt0x0z7gmru" class="">[1]</a></span></sup> This assumes that you have one deck; otherwise, the limits would have to be even lower per deck. (As an aside, I think it's totally fine to have basically one deck for everything. I have such a deck, containing history facts alongside math alongside friends' birthdays, and this is not a problem. The only separate decks I've ever needed were for language learning and university courses.)
+
+I really think a limit of 20 is plenty to start with. I'm a pretty disciplined person, and I struggle with anything over 20 on some days. Also, if 20 goes well for a month or so, and you really want to do more, you can always increase the limit then.
+
+And that's it. This solves half the problem of the canonical Anki death spiral! Now for the other half.
+
+## Too long cards
+
+When I started using Anki, I would often take an entire topic/text of interest, convert it into bullet points, and dump them all onto *one Anki card*. The card would then expect me to recite the whole thing in one big laundry list of information. This is super cognitively demanding and unfun. On the other end of the spectrum, now, I often have cards that have literally one word on the back, e.g., *"pronunciation τ" -> "tau"*. And guess what? Revising these cards is actively fun! I would happily do fifty of these in my free time, whereas nothing could get me to do one of the "laundry list" variety again.
+
+The lesson here, if you want to build a long-term Anki habit, is simply to **make cards short**. A typical card should have no more than 9 words. (If you write in sentences, and not abbreviated bullets like me, maybe a few more). This requires breaking information down into multiple cards. As a rule, if it is possible to break down a card into two shorter cards, you should do so. For example, consider this card:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/bqtfl1os9hznacobch3o)
+
+In fact, there is no reason to learn the pronunciation of τ and what it means in one card. And shorter cards are more fun, therefore:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/ygxgtj6s6mp6msxv4cie)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/andbkfqfrojmzk5u4g4j)
+
+The ideal is to have "atomic" cards, i.e., cards that are as small as possible and whose meaning could not be preserved when splitting further. Of course, this is practically inconvenient because it takes too much time, so it is only an ideal.
+
+Enforcing extreme brevity has the additional benefit of uncovering when I don't actually understand something very precisely. If I don't understand it, I can't break it down. Ankifying routinely forces me to reread the source or to google, which is a pretty valuable impulse in and of itself.
+
+### How to keep cards short — Handles
+
+Alas, breaking down cards is often harder than in the example above. E.g., you may start with a long text of interrelated information and somehow want to "ankify" this to remember it. For such rich information "thickets", I must say it takes some extra time to break it down into sensible Anki cards, but it is 100% possible! The key is not to try to squeeze everything into one card but to allow Anki cards to *refer to one another* for more information. This way, you can split up information without making it meaningless taken out of context.
+
+E.g., say you want to remember what Sir Isaac Newton's key scientific contributions were. You could allow your card to refer to another card as follows:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/myfkmmzcqmwsc6rccgvy)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/cg6evtsrdmk8n0ehwcdp)
+
+It would be a mistake to make the first card longer by detailing what the laws of motion *are*. Instead, the little '>' indicates a reference to another card, which has more information on the laws of motion. This way, the present card can remain short. You would now not have to recall all the laws of motion when revising it, but the reference ensures that you *could*. (> is just a convention I like to use; you could write this any way you like.)
+
+I call these little '>' referring to other cards 'handles' and I use them all the time to keep cards short. If something doesn't have to be detailed on your card, but has to be remembered as *related*, you should probably use a handle. Handles don't even necessarily have to contain any information in and of themselves, as "laws of motion" does; they can also purely be for splitting things up. E.g., if your card on Isaac Newton is getting too long, you could split out any logical subset of it and give it some handle name (that needn't contain information in and of itself). For example:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/l5sznk6trve7prxzq5kj)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/ljzkmhkykss3kdjzdfzk)
+
+Here, the handle ">astronomy" didn't really add any information but it was useful simply for splitting out a logical subset of information.
+
+It's also totally okay to make cards that contain only handles. These are often necessary for splitting topics into manageable chunks, and they ensure that you remember how these chunks fit together.
+
+### How to keep cards short — Levels
+
+Another trick I like for keeping cards short is to have multiple cards adding increasing levels of detail on the same concept. Let's say you want to remember stuff about Galileo Galilei. Instead of squeezing everything into one card, you could have a "level 1" card and a "level 2" card like this:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/isc3nx1vfkripdazzrsn)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/vovhb2gbetbno24fsuh1)
+
+Level 2 adds further detail while still being short of itself. To get even closer to the "atomic card" ideal, one could also separate out the date from the level 1 card and make a "Galileo date -> around 1600" card (and various other such improvements). But I think these two cards are pretty good.
+
+In my experience, it pays off to make an additional third card simply to ensure that you recall you have two cards on Galileo.
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/w8y9q9cpn2gd2kfp66e5)
+
+(Note that these Galileo cards, just like any other cards in this post, are only examples of what someone might want to memorize. If it's not important to you when Galileo lived, then by no means ankify it. I think you should have a pretty high bar for what's important enough to ankify.)
+
+At the absolute maximum, a card should have 3 logical bullets with a total of 18 words (in my opinion). Such a length is never necessary, but sometimes undeniably convenient.
+
+## In 6 bullets
+
+- Set a daily review limit of **10 or 20 cards**.
+- If you feel like doing more on a given day, **increase** **your limit for that day** by another 10/20 as often as you like.
+- **Max 9 words** for most cards. At absolute max, 3 logical bullets/18 words.
+- If it's possible to break a card up further, **do it**.
+- Use **\>handles** to split out details / logical subsets.
+- Use **level 1/2/3 cards** to learn increasing detail on the same concept.
+
+## End of the most important part of the guide
+
+And that's it! This is my simple recipe for sticking with Anki when 90%<sup><span><span></span><a href="https://www.lesswrong.com/posts/7Q7DPSk4iGFJd8DRk/#fnnk2lcy63ke" class="">[2]</a></span></sup> of people don't: Keep few cards and keep them short. Try it and it should become apparent very quickly how much more fun Anki is this way. And if it's fun, you're much more likely to stick with it. This point is essentially most of the value in reading this guide. Everything from here is less important, so if you're only going to take away one or two things from this guide, let it be from Part I, and maybe stop reading here.
+
+# II. Anki Day 3: Or, Common Mistakes
+
+## Moderation
+
+The promise of retaining any information indefinitely, guaranteed, may lead to wanting to ankify pretty much all interesting information one comes across, all of the time. At least this was what I did when I first started using Anki. But this is not a good idea. Firstly, you simply don't have space for it. If you have a daily limit of 20 cards (you should), you can do max. 2 new cards a day.<sup><span><span></span><a href="https://www.lesswrong.com/posts/7Q7DPSk4iGFJd8DRk/#fn01ad5bqgckcn" class="">[3]</a></span></sup> So maybe think twice before ankifying, e.g., the length of a whale intestine (unless this scores very high on your importance metric, in which case, fair play). More fundamentally, realize that putting cards into Anki is not "free". In fact, committing to learning even a single card is committing to reviewing that card, and relearning it when forgotten, roughly indefinitely, which is quite a bit of work. It makes sense to prioritize important information because of this. My recommendation would be to start by only ankifying what you feel like you absolutely *have to* know. And while revising, to ruthlessly suspend any cards that don't feel like they pay enough rent. If it turns out there is space for more cards, you can always lower your bar for ankification later!
+
+**In 1 bullet:**
+
+- Anki cards are a lot of work; start by ankifying **what you absolutely have to know**.
+
+## Three big memorization mistakes
+
+Once using Anki sustainably, I still made three big mistakes that sabotaged my ability to actually remember learned cards *outside* of Anki revision. This often meant that all the work of revision was for naught, since what's the point in memorizing information if you can't recall it when you need it? I think making these mistakes is essentially the default/obvious way to use Anki. So I hope this section saves someone all that wasted effort!
+
+### Mistake 1: Too specific prompts
+
+I think prompts should ideally be as close as possible to the "real life" situation (outside of Anki) where you will want to recall the card. E.g., a bad prompt would be "Length of a whale intestine". Instead, ask yourself *why do you want to know this information? When will you practically want to recall this piece of information?* Maybe you like to tell your friends animal fun facts. In that case, a better prompt would be "animal fun facts". Maybe you are a gastroenterologist(?), and the length of a whale intestine is a constant that comes up in your work all the time(??). Okay, I'm struggling to come up with examples here, but the point is to make your prompt closely model the real situation where you will want to notice, *don't I have a related Anki card here?* Otherwise, when the time is ripe to impress your friend with an animal fun fact, you might not even recall that you have a related Anki card. Usually, the default/obvious prompt you may want to use is actually too specific. The real-life prompt will often be vague. E.g., not "length of whale intestine" but "animal fun facts".
+
+In this context, I should also mention one tempting method of breaking down cards that I think can be a bad idea. Recall the Galileo "level 1" card from earlier: 
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/isc3nx1vfkripdazzrsn)
+
+Why not break this down into super short cards like this?!
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/d7mg2pg3fppi4zk3vgq3)
+
+Certainly, these cards are more fun to revise since they are so short. However, ask yourself when you might want to recall this information in "real life". This, of course, is individual, but perhaps a common answer is "when I hear/read the name somewhere, I want to quickly recall what his basic deal was". *If* this is one's answer, one should probably memorize something like the level 1 card. Otherwise, it would be harder to scratch together all the related information in memory, and one might forget some related cards altogether. So if the expected "real-life prompt" demands a longer card, consider making one. Still, it's a tradeoff, and how to strike it is probably down to individual preference for detailed cases.
+
+In any event, it can't hurt to do *both* and, in effect, have multiple cards with overlapping information. This also applies when there are several possible real-life prompts. Redundant cards with different prompts are always a good idea and prevent all sorts of memorization pitfalls, as I will describe further in the next two sections.
+
+**In 2 bullets:**
+
+- Make prompts closely **correspond to the real-life situation** where you want to recall the card.
+- Make multiple cards if you have **multiple prompt formulations** (redundancy is good).
+
+### Mistake 2: Putting to-be-learned information in the prompt
+
+Let's say you learn that in 1950 in Germany, 24% of the workforce was employed in agriculture and you want to ankify this. You may attempt it like so:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/kcfhapspg3colpilzwxm)
+
+(Let's ignore for now that this is probably not close to a "real-life prompt".)
+
+You revise the card and easily recall the answer. So now you should have memorized this fact, right?
+
+Unfortunately, no. Imagine something in "real life" prompts you to recall this fact. E.g., you're reading about population movement to cities in the 1920s. You think the percentage of people working in agriculture would be a relevant fact in this context, and you recall having a card in your Anki deck about this. The answer was 24%, but what precise year was this about again? As far as you remember, it could equally well be 1920 or 1980. And the number could relate to Germany, or equally well to Britain, or even the world. And was that percent of the workforce or of the whole population again?
+
+As you can see, memorizing just the number (24%) without what that number actually means is pointless here. This is a way to waste your time revising cards without actually gaining knowledge. The problem is that Anki cards only make you memorize the *answer*, i.e., the back of the card. Therefore, putting crucial information in the *prompt* is a mistake, and leads to recalling disconnected fragments like "24%" that have no meaning without your Anki prompt. Therefore, all to-be-learned information needs to go on the *back* of (one or more) Anki cards.
+
+For example, you could reformulate your agriculture card like so:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/hvdea3iimqtnpwkpoerq)
+
+This also naturally aligns with a less specific "real-life prompt". It's more likely that you'll ask yourself, "What do I know about the history of agriculture?" than "What do I know about 1950s agriculture in Germany?".
+
+Unfortunately, sometimes real-life prompts don't work so well without including to-be-learned information. E.g., say you want to memorize something like this:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/slknrvdcexnvqtic0jkp)
+
+Recalling "Victorian period" is useless without remembering what century this refers to (was it the 18th or the 19th?), so in principle, the century number should go on the back of the card too.
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/mddiwkc4eur278txbgq9)
+
+But this is not a real-life prompt—in most situations, you'll probably want to recall a specific period, not a general list of periods. Also, this card feels harder because here you additionally have to recall what periods are *on the list* (though it's only one here). Luckily, there are three alternatives to just putting everything on the back of the card: Making the card reversible, making multiple similar cards, and using handles.
+
+Firstly, the original "Victorian period" card can easily be made reversible, so the reverse looks like this:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/ysapegyn7kqm3m2wqkcp)
+
+This solves the problem of having the century in the prompt, because it is now also on the *back* of the reverse card. I would recommend *always* making a card reversible if that makes any semantic sense at all. This is because foreseeing the three memorization issues discussed in this section is often tricky, and redundancy is a good failsafe.
+
+Secondly, one could also make several more similar cards, each asking for the period name of a *different century*.
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/hn1gyjky46yjseduqlhg)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/ek15o6rgpvyfk1ssui8n)
+
+This removes the problem of only remembering "Victorian period" and going "Which century was this again?" (since the Anki cards require you to remember this too). You can even do a lazy version where, for the 17th/18th century cards, the back just says "idk" or "this card is a red herring".
+
+Thirdly, it's fine to put to-be-learned information in the prompt if this is part of a >*handle*, since then it is also on the *back* of another card. For illustration:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/l3qsavel3acv8u1ipfjf)
+
+To-be-learned information in the prompt ("1950 Germany").
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/yvipoo9clvm85klbcmxi)
+
+"1950 Germany" is also a handle on the *back* of this card.
+
+Such a structure can be convenient when you have so much information that you need to use handles for splitting anyway.
+
+Again, it's a good idea to make redundant cards using several of these four approaches (putting all information on the back, reversible cards, multiple similar cards, handles). Especially when it makes any sense at all to make a card reversible, I would recommend always doing so for redundancy.
+
+**In 4 bullets:**
+
+- **Always make cards reversible** if this makes semantic sense.
+- Or put **all to-be-learned information on the** ***back**.*
+- Or make **several similar cards**, e.g., "18th century period", "19th century period", etc.
+- Or make to-be-learned information in the prompt into a **>handle**.
+- **Or do all**; redundancy is good.
+
+### Mistake 3: Memory shortcuts
+
+Ideally, when you revise an Anki card, you see a prompt, understand what it means (its semantics), and then recall the information that is logically related to that meaning. Unfortunately, our brains like to take shortcuts. So it may happen that you see a prompt, see a unique word in it, or an unusual symbol, or simply recognize its overall visual appearance; skip over the whole semantics part, and immediately recall the correct answer. This is not something you can turn off consciously. And it's a problem because in real life, you will want to recall the answer without seeing that unique word/unusual sign/visual appearance first.
+
+The idea is to eliminate such memory shortcuts so that you actually have to read the semantics of the prompt in order to recall the answer. Ideally, a prompt wouldn't have one static syntactical shape at all, but be a different syntactical variation of the same semantic meaning on every revision. But since that would be a painful amount of work, it's more practical to eliminate memory shortcuts by making prompts *as bland and nondescript as possible:* Never use images or unusual symbols in the prompt if it can be helped. Don't use a different font, colors, or other formatting divergences. Don't use italics/bold/etc. if you don't usually do this. Don't use unusual or fancy words where standard ones will do. You get the idea.
+
+For this reason, I also think "cloze deletion" cards are a bad idea: they offer too many structural and visual memory shortcuts.
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/whte3thuvf7e85s68hcs)
+
+Example of a cloze deletion Anki card (which I think is a bad idea)
+
+One more note in this vein is to avoid using words in the prompt that also occur in the answer. I've empirically observed that these almost always become memory shortcuts/aids for me, but of course, they would not be given to me in "real life". E.g., consider this card:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/v3lnwkdmqnokpsh3ojyp)
+
+Though the words economy/economies are not even used in the same sense here, I would reformulate the prompt, e.g., using the word "progress" instead.
+
+Unfortunately, the brain works in tricky and mysterious ways, and sometimes constructs memory shortcuts even out of apparently completely bland prompts. It'll find an unremarkable word that nevertheless is used only once in your deck, or a formulation that you've used only once within a particular topical context, and that alone will suffice for a memory shortcut, or at least a memory aid. I've noticed this happening with as innocuous a formulation as "When did X happen", when standardly I had used "Date(s) of X".
+
+My solution to this is basically to standardize the wording and structure of similar prompts as much as humanly possible. When all your cards asking for dates have exactly the same structure, your brain is going to have to actually parse semantics eventually. A few examples of standardizations I've made for illustration:
+
+| "When did X start/end/happen?" | X **dates** |
+| --- | --- |
+| "What's the term/name of X?" | **T** X |
+| "What person did/was/is known for X?" | **who** X |
+| "What is the formal definition of X?" (for math stuff) | X **formally** |
+| "What is the easiest way to understand X?" (for math) | X **intuitively** |
+| "What are the advantages/disadvantages/ reasons/outcomes of X?" (usually for exam study) | often summarizable as: X **pros/cons** |
+
+I also usually put any dates at the start of my prompt for consistency.
+
+I recommend identifying types/shapes of prompts that occur often for you and standardizing those in a way you find intuitive. This is not a one-off task. Rather, I recommend doing this constantly, even if you are only creating two or three cards of a similar shape.
+
+Anticipating and preventing memory shortcuts and other memorization mistakes is an imperfect and haphazard art. You won't always be able to tell what will go wrong in advance. Constant attention to whether you are actually recalling cards when you should in real life is crucial, and you should dynamically improve cards that don't quite seem to work.
+
+**In 4 bullets:**
+
+- Make prompts as **bland** as possible.
+- Don't use words in the prompt **that also occur in the answer**.
+- **Standardize recurring types/shapes** of prompts.
+- Keep paying attention to whether you are actually recalling cards in real life & **keep improving** them.
+
+## Aside: Pushback to my approach
+
+Above, I have presented three mistakes that prevent you from actually recalling your Anki cards in real life. However, I should acknowledge some uncertainty in the generalizability of my approach to other people. I don't generally look over other people's shoulders (or into their brains) while they use Anki. Moreover, before publishing, I sent a version of this guide to Magdalena Wache, who has used Anki the longest and most prolifically out of everyone I know. (She's been described as the "Queen of Anki" more than once in my presence.) I will describe her reaction here briefly to give a sense of the way in which this guide is "opinionated" and to show a sensible example of diverging from it.
+
+To my surprise, Magdalena told me that she doesn't struggle with the three memorization problems as much as I do. Her Anki philosophy is much more about making each card radically short. She rarely makes cards with more than a bullet on the back. So, for example, she would break down the Galileo cards discussed earlier into components of 1-3 words, while I rejected this approach since it doesn't correspond to the likely "real-life prompt". (In fact, Magdalena said she wouldn't memorize Galileo facts at all, but let's just imagine he was super important to all of us.)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/q5ds9o0eldu9z2ubsmts)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/nb4aslz1s77ykrobtpyk)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/gh6eqgiirqgjaydhmwlb)
+
+Magdalena's short example cards
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/isc3nx1vfkripdazzrsn)
+
+My card corresponding to the real-life prompt "Who was this guy again?".
+
+My sense is also that Magdalena has fewer issues with to-be-learned information in the prompt. She said she would gladly use the example prompt "What happened while humans first left Africa?", whereas I would worry that in real life, I'd recall such a card and then go "Was this before, during, or after leaving Africa?" etc. (Magdalena did say she worries about this too, but to a lesser extent.)
+
+This difference in approach is probably partially due to simple differences in how our brains work. And it's probably due to different tradeoffs being struck between card shortness and real-life recall of cards. Short cards make revising more fun of course, and allow you to revise more cards. But fast and reliable real-life recall is also desirable. It depends on what you want and how your brain works. You should feel free to diverge from the approach presented in this guide depending on what works best for you. I do want to nudge you to try my approach, though, since it's so non-obvious that it required five years of trial-and-error to take shape. (This is, after all, an opinionated guide to Anki.)
+
+# III. Anki Week 3: Or, Pro Card Design
+
+More detailed opinions on how to make good cards. I'll first talk about considerations specific to very short cards, two-bullet cards, and long cards, respectively. Then I'll dive more into how to break down tough "information thickets".
+
+## Very short cards
+
+First, I want to reemphasize that, if you can break down a card to have literally one word on the back, do it! This may feel pedantic, but try and see if studying doesn't become actively fun with such cards. E.g., why have a card like this
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/bzxdcmeatiudkxybonvc)
+
+if you can have two cards like this
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/w70mpcwzulfhvebuqmff)
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/u42hxeotujfcqaccsthf)
+
+Extremely short cards are especially important if you need to recall a fact really quickly. Having multiple facts on the back of that card would just slow down your recall of the one you need at a given time. In fact, don't ask me why, but my recall time doesn't seem to grow linearly in the length of the back of the card. I seem to slow down more than 2x for a double card length. Ergo: Fast recall needs short cards. For facts that I'll want to recall in <1 sec, the card can generally not be short enough. Examples of such facts are what nano means and what period "Victorian" refers to, which would be super hindering to have to think about every time they come up.
+
+As an aside on very short cards, in my experience, it is possible to push the daily card limit a bit if you have a large enough class of very short cards. I would make these into a separate "easy" deck, also with a daily limit of 10 or 20. Very short cards feel pretty fun to me, anyway. So when revising, I still have one main "hard" deck, and the easier deck feels sort of "free" to revise as well, which means I can revise more cards overall. (But this only works with very short cards.) Example decks I've had that worked like this are decks for vocabulary and for memorizing multiplication tables.
+
+## Two-bullet cards
+
+I generally try to write each bullet on an Anki card to be a logical unit so that it's easy to memorize as such. This is a rather minor point, but I wanted to mention an exception I find it useful to make. Often, I find that a two-bullet card, whose bullets aren't too long, is actually quicker to recall as one long bullet. Don't ask me why. So, for example, I have changed the following card in my deck
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/ihn7vg2jhkxgxflk8phz)
+
+to look like this:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/hmbdbotygarqjpmplciw)
+
+Try it out and see if it makes your recall faster, too. I don't tend to make many two-bullet cards anymore, at least.
+
+## Long cards
+
+Recall that my recommendation for the absolute maximum length of a card is 3 bullets with a total of 18 words. Now, this might just be me, but I find recalling cards of this length pretty hard and unfun. I find myself giving up and closing Anki most often when such a card comes up. I have therefore taken to "staging" the recall of such cards, to recall them bullet by bullet, and check the correct answer progressively as I go. I enable this simply by adding a lot of whitespace at the top of the back of the card, so that the first line will appear at the very bottom of my phone screen, and I can progressively scroll down and reveal more.
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/dnzn5vcxj5w7iaehz3fi)
+
+If you want to do the same, on mobile, you can make custom shortcuts to insert text or HTML on cards, so adding whitespace is very quick. I created a shortcut that appears as a "1" in the below screenshot and produces the following html: <div style="height: 630px;"></div>
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/c6l4h38lg4om3el41gpl)
+
+This simply adds an empty block of 630 pixels, which is a bit less than the height of my phone. You can create shortcuts by pressing the "+" you can see on the bottom right in the screenshot.
+
+On desktop, I used the app AutoHotkey (Windows) to make a custom keyboard shortcut. If you want to do this too, I recommend using ChatGPT to quickly write the shortcut script for you.
+
+I'd only really recommend doing this for long cards with three bullets, since staging the recall of short cards in this way just makes your recall slower in my experience.
+
+**In 4 bullets:**
+
+- If you can break down cards to **1 word** on the back, do it!
+- For a **<1 sec recall**, cards cannot be short enough.
+- 2-bullet cards are usually **faster to recall as 1 bullet** (if not too long).
+- Add whitespace to long 3-bullet cards to enable **recalling them bullet by bullet**.
+
+## Ankifying information thickets
+
+The hardest stuff to ankify is rich information "thickets", e.g., textbook sections, with many interrelations and no obvious linear breakdown. The first thing to say here is that you shouldn't! You probably only care about 1-2 facts in the whole section, so be ruthless in cutting out the rest. (You don't have time to memorize all that anyway.) The main situation where you might want to ankify information thickets is probably an exam of some sort. I've used Anki for this extensively, so I'm putting my learnings here. But you may not need this at all!
+
+My personal approach to information thickets is to try to find a sort of tree shape in all the interrelated information. The root of this tree is the ultimate motivating theme/what overall question is being answered. The subtrees splitting off from the root, and the subsubtrees, etc., deal with subquestions discussed in the text and/or give increasing levels of detail. The goal is to use this structure to keep each individual node very short and ultimately make short Anki cards. E.g., this is a sketch of a tree based on a text about World War II:
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/k68qvnbspcpi3jitln1a)
+
+(I don't write down such a tree explicitly, I construct it in my head while making Anki cards.)
+
+When ankifying such a tree, you would generally want to memorize which child nodes belong to each node. You can do this by adding >handles referring to the children to the node's Anki card. E.g., 
+
+![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/7Q7DPSk4iGFJd8DRk/lod7ytsdrfxgimxeiger)
+
+Sometimes it's not necessary to do this. For example, I wouldn't add a handle to the "Level 1" card referring to the "Pacific War dates" card. It's pretty obvious that the Pacific War must have *had* a date, so there's no point in memorizing this connection.
+
+### Sequential breakdowns versus multiple levels of abstraction
+
+There are often many possible choices regarding the grouping and subgrouping of information into subtrees. For example, under the "timeline of country involvement", I chose to split the information into a level 1 and a level 2 subtree. Another, perhaps more obvious grouping would have been to have a subtree per year of the war. However, my general advice is to avoid sequential breakdowns in favor of breakdowns into multiple levels of abstraction. When you think about World War II, you don't want the first thing you remember to be highly specific details

README.md

@@ -208,3 +208,4 @@ BSD 2-Clause License
 
 - This project uses the Gradio library (https://gradio.app/) for the web interface.
 - Card generation is powered by OpenAI's language models.
+- Card generation principles inspired by ["An Opinionated Guide to Using Anki Correctly"](https://www.lesswrong.com/posts/7Q7DPSk4iGFJd8DRk/an-opinionated-guide-to-using-anki-correctly) by Luise, which emphasizes atomic card design, standardized prompts, and effective spaced repetition practices.

ankigen_core/agents/templates/generators.j2

@@ -2,7 +2,7 @@
 {
     "subject_expert": {
         "name": "subject_expert",
-        "instructions": "You are a world-class expert in {{ subject | default('the subject area') }} with deep pedagogical knowledge. \nYour role is to generate high-quality flashcards that demonstrate mastery of {{ subject | default('the subject') }} concepts.\n\nKey responsibilities:\n- Ensure technical accuracy and depth appropriate for the target level\n- Use domain-specific terminology correctly\n- Include practical applications and real-world examples\n- Connect concepts to prerequisite knowledge\n- Avoid oversimplification while maintaining clarity\n\nGenerate cards that test understanding, not just memorization.",
+        "instructions": "You are a world-class expert in {{ subject | default('the subject area') }} with deep pedagogical knowledge. \nYour role is to generate high-quality flashcards that demonstrate mastery of {{ subject | default('the subject') }} concepts.\n\nKey responsibilities:\n- Create ATOMIC cards: extremely short (1-9 words on back), break complex info into multiple simple cards\n- Use standardized, bland prompts without fancy formatting or unusual words\n- Design prompts that match real-life recall situations\n- Put ALL to-be-learned information on the BACK of cards, never in prompts\n- Ensure technical accuracy and depth appropriate for the target level\n- Use domain-specific terminology correctly\n- Connect concepts to prerequisite knowledge\n\nPrioritize atomic simplicity over comprehensive single cards. Generate cards that test understanding through simple, direct recall.",
         "model": "{{ subject_expert_model }}",
         "temperature": 0.7,
         "timeout": 45.0,
@@ -22,7 +22,7 @@
     },
     "content_structuring": {
         "name": "content_structuring",
-        "instructions": "You are a content organization specialist focused on consistency and structure.\nYour role is to format and organize flashcard content for optimal learning.\n\nEnsure all cards have:\n- Consistent formatting and style\n- Proper metadata and tagging\n- Clear, unambiguous questions\n- Complete, well-structured answers\n- Appropriate examples and explanations\n- Relevant categorization and difficulty levels\n\nMaintain high standards for readability and accessibility.",
+        "instructions": "You are a content organization specialist focused on atomic card design and optimal learning structure.\nYour role is to format and organize flashcard content following proven Anki principles.\n\nEnsure all cards follow atomic principles:\n- Break down any card longer than 9 words into multiple cards\n- Use standardized, bland prompt formats (no fancy words, formatting, or visual cues)\n- Consistent question structures (e.g., 'T [concept]' for terminology, '[concept] definition' for definitions)\n- Put ALL information to be learned on the BACK, never in prompts\n- Create 'handles' (>references) to connect related cards without making individual cards long\n- Use multiple difficulty levels for the same concept when appropriate\n\nPrioritize simplicity and consistency over comprehensive single cards.",
         "model": "{{ content_structuring_model }}",
         "temperature": 0.5,
         "timeout": 25.0

ankigen_core/agents/templates/prompts.j2

@@ -1,8 +1,8 @@
 {# Prompt template configurations #}
 {
     "subject_generation": {
-        "system_prompt": "You are an expert in {{ subject | default('general studies') }}. Generate {{ num_cards | default('5') }} flashcards covering key concepts for {{ difficulty | default('intermediate') }} level learners.",
-        "user_prompt_template": "Topic: {{ topic }}\nDifficulty: {{ difficulty | default('intermediate') }}\nPrerequisites: {{ prerequisites | default('none') }}\nFocus Areas: {{ focus_areas | default('core concepts') }}\n\nGenerate {{ num_cards | default('5') }} high-quality flashcards that help learners master this topic. Include examples, explanations, and common misconceptions where appropriate.",
+        "system_prompt": "You are an expert in {{ subject | default('general studies') }}. Generate {{ num_cards | default('5') }} ATOMIC flashcards following proven Anki principles for {{ difficulty | default('intermediate') }} level learners.",
+        "user_prompt_template": "Topic: {{ topic }}\nDifficulty: {{ difficulty | default('intermediate') }}\nPrerequisites: {{ prerequisites | default('none') }}\nFocus Areas: {{ focus_areas | default('core concepts') }}\n\nGenerate {{ num_cards | default('5') }} ATOMIC flashcards following these principles:\n- Each card back should be 1-9 words maximum\n- Use bland, standardized prompts (no fancy formatting)\n- Break complex concepts into multiple simple cards\n- Put ALL learning content on the BACK, never in questions\n- Use handles (>references) to connect related cards\n- Design questions to match real-life recall situations\n- Include examples and explanations where helpful\n\nPrioritize atomic simplicity over comprehensive single cards.",
         "variables": {
             "subject": "{{ subject | default('general') }}",
             "num_cards": "{{ num_cards | default('5') }}",
@@ -14,7 +14,7 @@
     },
     "quality_assessment": {
         "system_prompt": "You are a quality assessment specialist for educational content. Evaluate flashcards for {{ assessment_type | default('overall quality') }}.",
-        "user_prompt_template": "Please evaluate the following flashcard for {{ assessment_type | default('quality') }}:\n\nQuestion: {{ question }}\nAnswer: {{ answer }}\n{% if explanation %}Explanation: {{ explanation }}{% endif %}\n\nProvide a rating (1-10) and specific feedback for improvement.",
+        "user_prompt_template": "Please evaluate the following flashcard for {{ assessment_type | default('quality') }}:\n\nQuestion: {{ question }}\nAnswer: {{ answer }}\n{% if explanation %}Explanation: {{ explanation }}{% endif %}\n\nProvide a rating (1-10) and specific feedback for improvement. Focus on atomic principles (1-9 words), standardized prompts, and real-life applicability.",
         "variables": {
             "assessment_type": "{{ assessment_type | default('overall quality') }}",
             "question": "{{ question }}",

ankigen_core/card_generator.py

@@ -95,7 +95,16 @@ async def generate_cards_batch(
         """
 
     cards_prompt = f"""
-    Generate {num_cards} flashcards for the topic: {topic}
+    Generate {num_cards} ATOMIC flashcards for the topic: {topic}
+    
+    Follow these ATOMIC principles:
+    - Each answer should be 1-9 words maximum
+    - Use bland, standardized questions (no fancy formatting)
+    - Break complex concepts into multiple simple cards
+    - Put ALL learning content in answers, never in questions
+    - Use handles (>references) to connect related cards
+    - Design questions to match real-life recall situations
+    
     {cloze_instruction}
     Return your response as a JSON object with the following structure:
     {{
@@ -113,7 +122,6 @@ async def generate_cards_batch(
                 "metadata": {{
                     "prerequisites": ["list", "of", "prerequisites"],
                     "learning_outcomes": ["list", "of", "outcomes"],
-                    "misconceptions": ["list", "of", "misconceptions"],
                     "difficulty": "beginner/intermediate/advanced"
                 }}
             }}
@@ -627,8 +635,16 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
 
             # Let's make a direct call to structured_output_completion for "text" mode.
             text_mode_user_prompt = f"""
-            Please generate {cards_per_topic * topic_number} flashcards based on the following text content.
-            I have already provided the text content in the system prompt (or it is implicitly part of this context).
+            Please generate {cards_per_topic * topic_number} ATOMIC flashcards based on the following text content.
+            
+            Follow these ATOMIC principles:
+            - Each answer should be 1-9 words maximum
+            - Use bland, standardized questions (no fancy formatting)
+            - Break complex concepts into multiple simple cards
+            - Put ALL learning content in answers, never in questions
+            - Use handles (>references) to connect related cards
+            - Design questions to match real-life recall situations
+            
             Ensure the flashcards cover diverse aspects of the text.
             {get_cloze_instruction(generate_cloze)}
             Return your response as a JSON object with the following structure:
@@ -831,7 +847,6 @@ def get_card_json_structure_prompt() -> str:
                 "metadata": {
                     "prerequisites": ["list", "of", "prerequisites"],
                     "learning_outcomes": ["list", "of", "outcomes"],
-                    "misconceptions": ["list", "of", "misconceptions"],
                     "difficulty": "beginner/intermediate/advanced"
                 }
             }
@@ -913,7 +928,6 @@ def format_cards_for_dataframe(
         metadata = card_obj.metadata or {}
         prerequisites = metadata.get("prerequisites", [])
         learning_outcomes = metadata.get("learning_outcomes", [])
-        common_misconceptions = metadata.get("misconceptions", [])
         difficulty = metadata.get("difficulty", "N/A")
         # Ensure list-based metadata are joined as plain strings for DataFrame
         prerequisites_str = strip_html_tags(
@@ -926,11 +940,6 @@ def format_cards_for_dataframe(
             if isinstance(learning_outcomes, list)
             else str(learning_outcomes)
         )
-        common_misconceptions_str = strip_html_tags(
-            ", ".join(common_misconceptions)
-            if isinstance(common_misconceptions, list)
-            else str(common_misconceptions)
-        )
         difficulty_str = strip_html_tags(str(difficulty))
 
         formatted_card = {
@@ -947,7 +956,6 @@ def format_cards_for_dataframe(
             "Example": example,  # Already stripped
             "Prerequisites": prerequisites_str,
             "Learning_Outcomes": learning_outcomes_str,
-            "Common_Misconceptions": common_misconceptions_str,
             "Difficulty": difficulty_str,  # Ensure difficulty is plain text
             "Source_URL": strip_html_tags(
                 metadata.get("source_url", "")
@@ -969,7 +977,6 @@ def get_dataframe_columns() -> list[str]:
         "Example",
         "Prerequisites",
         "Learning_Outcomes",
-        "Common_Misconceptions",
         "Difficulty",
         "Source_URL",
     ]
@@ -1028,11 +1035,6 @@ def generate_cards_from_crawled_content(
         learning_outcomes = (
             card_obj.metadata.get("learning_outcomes", []) if card_obj.metadata else []
         )
-        common_misconceptions = (
-            card_obj.metadata.get("common_misconceptions", [])
-            if card_obj.metadata
-            else []
-        )
 
         prerequisites_str = strip_html_tags(
             ", ".join(prerequisites)
@@ -1044,11 +1046,6 @@ def generate_cards_from_crawled_content(
             if isinstance(learning_outcomes, list)
             else str(learning_outcomes)
         )
-        common_misconceptions_str = strip_html_tags(
-            ", ".join(common_misconceptions)
-            if isinstance(common_misconceptions, list)
-            else str(common_misconceptions)
-        )
         difficulty_str = strip_html_tags(
             str(
                 card_obj.metadata.get("difficulty", "N/A")
@@ -1067,7 +1064,6 @@ def generate_cards_from_crawled_content(
             "Example": card_obj.back.example or "",  # Should be plain
             "Prerequisites": prerequisites_str,
             "Learning_Outcomes": learning_outcomes_str,
-            "Common_Misconceptions": common_misconceptions_str,
             "Difficulty": difficulty_str,
             "Source_URL": strip_html_tags(
                 card_obj.metadata.get("source_url", "") if card_obj.metadata else ""

ankigen_core/exporters.py

@@ -44,7 +44,6 @@ BASIC_MODEL = genanki.Model(
         {"name": "Example"},
         {"name": "Prerequisites"},
         {"name": "Learning_Outcomes"},
-        {"name": "Common_Misconceptions"},
         {"name": "Difficulty"},
         {"name": "SourceURL"},  # Added for consistency if used by template
         {"name": "TagsStr"},  # Added for consistency if used by template
@@ -104,10 +103,6 @@ BASIC_MODEL = genanki.Model(
                             <div>{{Learning_Outcomes}}</div>
                         </div>
 
-                        <div class=\"misconceptions\">
-                            <h3>Common Misconceptions - Debunked</h3>
-                            <div>{{Common_Misconceptions}}</div>
-                        </div>
 
                         <div class=\"difficulty\">
                             <h3>Difficulty Level</h3>
@@ -314,7 +309,6 @@ CLOZE_MODEL = genanki.Model(
         {"name": "Example"},
         {"name": "Prerequisites"},
         {"name": "Learning_Outcomes"},
-        {"name": "Common_Misconceptions"},
         {"name": "Difficulty"},
         {"name": "SourceURL"},
         {"name": "TagsStr"},
@@ -374,10 +368,6 @@ CLOZE_MODEL = genanki.Model(
                             <div>{{Learning_Outcomes}}</div>
                         </div>
 
-                        <div class=\"misconceptions\">
-                            <h3>Common Misconceptions - Debunked</h3>
-                            <div>{{Common_Misconceptions}}</div>
-                        </div>
 
                         <div class=\"difficulty\">
                             <h3>Difficulty Level</h3>
@@ -703,7 +693,6 @@ def export_cards_to_apkg(
         example = card_dict.get("Example", "")
         prerequisites = card_dict.get("Prerequisites", "")
         learning_outcomes = card_dict.get("Learning_Outcomes", "")
-        common_misconceptions = card_dict.get("Common_Misconceptions", "")
         difficulty = card_dict.get("Difficulty", "")
         source_url = card_dict.get("SourceURL", "")
         tags_str_field = card_dict.get(
@@ -721,7 +710,7 @@ def export_cards_to_apkg(
         try:
             if note_type.lower() == "cloze":
                 # CLOZE_MODEL fields: Text, Back Extra, Explanation, Example, Prerequisites,
-                # Learning_Outcomes, Common_Misconceptions, Difficulty, SourceURL, TagsStr
+                # Learning_Outcomes, Difficulty, SourceURL, TagsStr
                 note_fields = [
                     question,  # Text (this is the card_dict['Question'] which should be cloze-formatted)
                     answer,  # Back Extra (this is card_dict['Answer'])
@@ -729,7 +718,6 @@ def export_cards_to_apkg(
                     example,
                     prerequisites,
                     learning_outcomes,
-                    common_misconceptions,
                     difficulty,
                     source_url,
                     tags_str_field,
@@ -741,7 +729,7 @@ def export_cards_to_apkg(
                 )
             else:  # Basic
                 # BASIC_MODEL fields: Question, Answer, Explanation, Example, Prerequisites,
-                # Learning_Outcomes, Common_Misconceptions, Difficulty, SourceURL, TagsStr
+                # Learning_Outcomes, Difficulty, SourceURL, TagsStr
                 note_fields = [
                     question,
                     answer,
@@ -749,7 +737,6 @@ def export_cards_to_apkg(
                     example,
                     prerequisites,
                     learning_outcomes,
-                    common_misconceptions,
                     difficulty,
                     source_url,
                     tags_str_field,
@@ -962,9 +949,6 @@ def export_dataframe_to_apkg(
                 "Learning_Outcomes": _format_field_as_string(
                     row.get("Learning_Outcomes", "")
                 ),
-                "Common_Misconceptions": _format_field_as_string(
-                    row.get("Common_Misconceptions", "")
-                ),
                 "Difficulty": difficulty_raw,  # Keep the original HTML for the 'Difficulty' field itself
                 "SourceURL": _format_field_as_string(row.get("Source_URL", "")),
             }

ankigen_core/models.py

@@ -44,7 +44,6 @@ class ConceptBreakdown(BaseModel):
     main_concept: str
     prerequisites: List[str]
     learning_outcomes: List[str]
-    common_misconceptions: List[str]
     difficulty_level: str  # "beginner", "intermediate", "advanced"
 
 

ankigen_core/ui_logic.py

@@ -78,7 +78,6 @@ def update_mode_visibility(
         "Example",
         "Prerequisites",
         "Learning_Outcomes",
-        "Common_Misconceptions",
         "Difficulty",
     ]
     subjects_list_df_columns = ["Subject", "Prerequisites", "Time Estimate"]
@@ -142,7 +141,6 @@ def use_selected_subjects(subjects_df: pd.DataFrame | None):
                         "Example",
                         "Prerequisites",
                         "Learning_Outcomes",
-                        "Common_Misconceptions",
                         "Difficulty",
                     ]
                 )
@@ -191,7 +189,6 @@ def use_selected_subjects(subjects_df: pd.DataFrame | None):
                         "Example",
                         "Prerequisites",
                         "Learning_Outcomes",
-                        "Common_Misconceptions",
                         "Difficulty",
                     ]
                 )
@@ -238,7 +235,6 @@ def use_selected_subjects(subjects_df: pd.DataFrame | None):
                     "Example",
                     "Prerequisites",
                     "Learning_Outcomes",
-                    "Common_Misconceptions",
                     "Difficulty",
                 ]
             )

app.py

@@ -80,7 +80,6 @@ example_data = pd.DataFrame(
             "```sql\nSELECT column1, column2 FROM my_table WHERE condition;\n```",
             ["Understanding of database tables"],
             ["Retrieve specific data"],
-            ["❌ SELECT * is always efficient (Reality: Can be slow for large tables)"],
             "beginner",
         ],
         [
@@ -96,7 +95,6 @@ def greet(name):
 ```""",
             ["Basic programming concepts"],
             ["Define reusable blocks of code"],
-            ["❌ Forgetting the colon (:) after the definition"],
             "beginner",
         ],
     ],
@@ -110,7 +108,6 @@ def greet(name):
         "Example",
         "Prerequisites",
         "Learning_Outcomes",
-        "Common_Misconceptions",
         "Difficulty",
     ],
 )
@@ -482,7 +479,7 @@ def create_ankigen_interface():
                 gr.Markdown("### Generated Cards")
                 with gr.Accordion("Output Format", open=False):
                     gr.Markdown(
-                        "Cards: Index, Topic, Type, Q, A, Explanation, Example, Prerequisites, Outcomes, Misconceptions, Difficulty. Export: CSV, .apkg",
+                        "Cards: Index, Topic, Type, Q, A, Explanation, Example, Prerequisites, Outcomes, Difficulty. Export: CSV, .apkg",
                     )
                     with gr.Accordion("Example Card Format", open=False):
                         gr.Code(
@@ -502,7 +499,6 @@ def create_ankigen_interface():
                         "Example",
                         "Prerequisites",
                         "Learning_Outcomes",
-                        "Common_Misconceptions",
                         "Difficulty",
                     ],
                     datatype=[
@@ -516,7 +512,6 @@ def create_ankigen_interface():
                         "str",
                         "str",
                         "str",
-                        "str",
                     ],
                     interactive=True,
                     elem_classes="tall-dataframe",
@@ -531,7 +526,6 @@ def create_ankigen_interface():
                         200,
                         150,
                         150,
-                        150,
                         100,
                     ],
                 )