How Kvela is built.

A language course is really two problems wearing one coat. The first is what to teach, and in what order. The second is how to keep the learner from forgetting it. Most apps answer the first by tradition (colours, animals, the family) and the second with a stock algorithm bolted on at the end. We tried to answer both from the research and the data up.

Kvela is one course for one language: more than three thousand cards, grouped into well over a hundred short modules, from the alphabet to indirect speech and the perfect tense. The deck was assembled by a pipeline (a corpus of real Georgian, a ranking tournament, a dependency graph, generated illustrations and audio) and then given a native-speaker review, card by card. We lean on AI to do at small-team scale what would otherwise take a department. We don’t pretend the machine gets Georgian right on its own. The sections below are roughly the order things happen in.

Before building anything, we spent real time in the research on how people actually remember. Not language-app folklore, the experimental literature, some of it a century old and rock-solid. What follows is the portable version: the principles that hold for any deck, in any language, ours included. If you take nothing else from this paper, take these. They’re free, and most courses ignore half of them.

None of this is ours. It’s the field’s. The work, and the rest of this paper, was in applying it to one underserved language without cutting the corners that make it pleasant to cut. The full sources are listed at the end.

You can’t teach all of a language, so the first real decision is which few thousand things to teach. Pick wrong and a learner spends month one on words they’ll use once a year. Frequency research makes the stakes concrete: because usage is Zipfian, the first thousand-odd words carry most of everyday conversation, so getting that core right matters more than anything that comes after. We started from how Georgian is actually used.

The backbone is a frequency list built from a large body of real Georgian text, broken into n-grams. An n-gram is just a run of n words in a row: წყალი (water) is a unigram, კარგი დილა (good morning) is a bigram, a short stock phrase is a trigram. Count how often each run appears across a lot of text and you get an evidence-based ranking of what Georgians say most: single words and the set phrases they travel in, not a textbook’s guess.

That frequency list is one of six sources. The others are a hand-built core vocabulary (with example sentences and priority flags), the 33 letters of the alphabet, a table of grammatical pieces (postpositions like -ში for “in” and -ზე for “on”, preverbs like მი- and გა-), and two tables of grammar patterns with example sentences. All six are normalised, merged, and then de-duplicated, which in Georgian is real work: a verb’s dictionary form and the matching noun are often the same word, and the same conjugated form can carry two unrelated meanings. Everything then passes a translation check before it goes near a learner.

The funnel, roughly: six source spreadsheets, then about 2,400 cards after merge and de-duplication, expanding past 5,000 candidates as the dependency graph (below) exposed missing prerequisites, then settling into the deck you actually learn from.

Raw frequency is a good start and a bad finish. The single most common token in almost any language is a grammatical word, Georgian’s equivalents of the and of, that teaches a beginner almost nothing on its own. So we don’t teach in frequency order. We rank every card by how useful it is to learn next, and we do it the way you’d rank chess players: pairwise, with an Elo score.

Each card starts with a seed score that combines the signals we already trust: where it falls on the frequency list, how many other cards depend on it (a word that unlocks fifty others is foundational, read straight off the dependency graph), whether a human flagged it essential, how complex it is, and how much we trust its source. Roughly:

score = 1000
      + log2(dependents + 1) × 50   how foundational
      + 150 if hand-flagged essential
      + frequency-rank bonus
      − 15 × (number of prerequisites)  how complex
      + source-trust bonus

Then comes the tournament. We repeatedly take two cards of similar score and ask a language model a single question:

Given two Georgian words or phrases, decide which one is more important to learn first. Consider frequency of use in daily life, practical value, foundational importance.

The winner’s score ticks up, the loser’s down, by the standard Elo update: about five matchups per card, with the rating moves starting large and shrinking as scores settle, so the order converges instead of jittering. Pairing similar-scored cards spends the comparisons where the ranking is genuinely uncertain, rather than re-confirming that ყოფნა (to be) beats some rare abstract noun.

One Georgian-specific wrinkle: a verb arrives as a whole paradigm, six persons of I am, you are, he is, and ranking those against each other is noise. So a paradigm competes as a single unit, represented by its most natural form, and the result is shared back across all six. What rises to the top is the kind of vocabulary you’d hope for: workhorse words like ყოფნა (to be), -ში (in), ეს (this), ძალიან (very). The very first lessons are then arranged by hand on top of this ranking, because a beginner’s first hour is too important to leave to a score.

The fastest way to make someone quit is a sentence with two words they’ve never seen and a grammar form they don’t know, all at once. The fix is Krashen’s i + 1, made literal: each new step should be mostly familiar, plus one new thing. The number is one and not two for a concrete reason: a learner can usually infer a single unknown from the words around it, but a second unknown collapses the guess. To enforce that you need to know, for every card, exactly what it depends on.

So we built a dependency graph: roughly fourteen hundred links of the form this card requires that one first. They come from asking a model to decompose each card into its parts (a phrase into its words, a word into its meaningful pieces, a conjugated verb into its dictionary form) and then matching those parts back to real cards in the deck. Conjugations are wired to their infinitive by rule. Where the decomposition pointed at something the deck didn’t yet contain, that gap became a new card to write.

With the graph in hand, the rule is mechanical: every prerequisite of a card must appear earlier in the course than the card itself, and a phrase should introduce at most one unfamiliar component. We check the whole course against this automatically. But the sharpest test we run is narrower and more human.

We audited all 518 verb cards that carry an example sentence, because that’s where the rule quietly breaks: a card drilling a verb slips in an object noun the learner has never met. The audit lemmatised each object (Georgian declines nouns heavily) and checked whether a standalone card for it existed earlier. It found 62 violations: 35 where the object noun is never taught anywhere, 27 where it’s taught only later. A core “do you know?” card asked მისამართს იცი? (do you know the address?), and the card teaching მისამართი (address) sat almost 500 positions further on. Another used პასუხი (answer) with no card of its own at all. The most useful findings were shared nouns like დახმარება (help) and პასუხი (answer), where seeding one card early fixes several lessons downstream.

That’s also the honest part. The n + 1 rule is audited and corrected, not mathematically guaranteed. The graph doesn’t yet track that a noun you met in one case is the same noun in another. Transparent international words (ტელეფონი, ტაქსი) are waved through by human judgement, not rule. And fixed expressions and proverbs are allowed to arrive whole. The checks run after content is written, not before, which is why we keep running them, and why a human reads behind them.

Most courses teach grammar the school way: here is the rule, here is the table of endings, now memorise it. That works for transparent systems and falls apart on Georgian, whose verbs fold preverbs, version vowels, and subject and object markers into shapes no beginner can hold as a table. The research has pointed the other way for decades. Learners pick up grammar faster, and use it more fluently, when they meet a form carrying real meaning many times before anyone names the rule. That is VanPatten’s processing instruction; Erlam (2003) found that inductive, example-first learners matched rule-first learners on comprehension and beat them on production.

Acquisition order also tracks how often you actually hear a form, not the order of a textbook chapter (N. Ellis, 2002). So the deck is built to feed the pattern rather than the rule. Because of the one-new-thing ordering from the last section, the example sentence on a card is made only of words you already know, so you can read it for meaning while the grammar rides along underneath. See the same shape in enough sentences and it stops being a rule and becomes an expectation. That intuition is the point: once you have it, the explicit rule, when you finally read it, only confirms what you already feel.

The tips are not grammar lectures. They are short nudges that name a pattern at the moment you’re ready to notice it (“the -ხარ here is the same you are from როგორ ხარ”), and they go quiet once you’ve seen it enough, since explicit instruction lands best after exposure, not before (Gor & Long, 2009; Ellis & Shintani’s focus on form). This is the harder course to build, and we’ll be honest that it’s a work in progress: some verb paradigms are still introduced closer together than the ideal, and moving every one of them into the flow of real sentences is ongoing. But the direction never reverses: meet the pattern first, name it second.

Georgian’s reputation for intimidating, consonant-stacked words is half a trick of the eye. The language is unusually regular: the same small pieces, a prefix meaning to me, a marker for you, a familiar root, reappear across hundreds of words. Morphological awareness is a documented accelerator (Kuo & Anderson, 2006): a learner who can see a word’s parts decodes the next word that shares them faster. The course is built to make those seams visible.

Take გამარჯობა (gamarjoba, “hello”). It isn’t one indivisible lump. It’s გა- (a preverb) plus მარჯვ- (the root of victory) plus -ობა (a noun-forming ending), roughly “victory to you.” Or მინდა (minda, “I want”), which carries the მ- “to me” marker you’ll meet again in მაქვს (maqvs, “I have”). Where a word has this structure, its card stores a breakdown (each piece, its meaning, and its job) so the explanation is built from parts you’ve already learned rather than asserted from nowhere.

Under that, a card is a small structured record: the Georgian, the English, a transliteration, a short tip, worked examples, the morpheme breakdown, related words, and, for verbs, the root, the tense, and the person, so the system understands a paradigm as a paradigm. The tip stays short by rule. The depth lives in the breakdown, where it belongs.

Spaced repetition is the spacing effect turned into a schedule: see a word just before you’d forget it, and each successful recall buys more time before the next. We tried the popular algorithms, SM-2 and FSRS, and kept hitting the same problem. They track two or three abstract numbers you can’t reason about, and the interval the learner sees can drift away from the memory model underneath, so a single answer makes a card jump in ways we couldn’t explain. We wanted a schedule a person could work out on paper. So we built one.

Each card carries a single number: how many days until you should see it again. Grade yourself and that number is just multiplied:

next interval = round( current interval × factor )

  miss   × 0.5    halve it, never reset to zero
  hard   × 1.2
  good   × 2.0    roughly double
  easy   × 3.0    triple

clamped to [ 1 day, 120 days ]

The detail that matters most is the miss: a forgotten card is halved, not wiped back to the start. Forgetting one word after a month shouldn’t cost you the month. Before any of this, a new card runs through a short same-session loop of a few quick repetitions (Pimsleur’s point that the first reviews have to happen minutes apart, not days, to get a word into memory at all) and only then graduates to the day-scale schedule above. Within a session a card’s grade is its worst answer, so a single stumble brings it back soon even if the next try was clean. When review is due, the cards shown first are the ones you’re closest to forgetting, measured as how far past due they are relative to their own interval. The whole thing is simple on purpose: nothing about your progress is a black box.

Every card carries its own illustration, because a vivid image gives an unfamiliar word something to hook onto, the same principle behind the keyword mnemonic (Atkinson, 1975), where pairing a word with a striking picture lifts recall above plain repetition. That matters doubly when the script itself is new. The pictures are generated, but not casually. A writing model first drafts an art-directed prompt for each card, working under firm constraints: no text in the image (so it’s the picture, not a written label, doing the remembering), a fresh artistic medium each time (the recent styles are fed back in as a hard “don’t repeat this” list, so the deck doesn’t collapse into one house style), and a pull toward Georgian specifics like tower-houses, a supra table, or a courtyard, over generic stock. An image model then renders it. One real prompt, for a card about having too much work, reads:

A figure sits almost buried at a desk behind teetering, toppling towers of papers, ledgers and files that rise far above their head, one weary hand propping up their brow. The sheer mountain of it. Expressive ink-and-wash illustration, loose energetic linework, busy crosshatched stacks, a muted overworked palette, the workload looming enormous.

It closes, as every prompt does, with an explicit “…without text” instruction, the line that keeps a written label from sneaking in and doing the remembering for you.

And every word and example sentence is spoken aloud, so pronunciation is part of learning from the first lesson rather than a correction much later. Here we’ll be exact, because it’s the kind of thing apps fudge: the audio is a high-quality synthesised voice, not a human native recording. It’s one consistent Georgian voice across the whole course, generated with a text-to-speech model chosen for its Georgian pronunciation, pitched slightly slow for clarity. It’s good, and it’s honest about what it is.

Everything above is how a small team can build a course this large: AI to curate, decompose, illustrate, and voice. But the language itself is too important to leave to a machine, and we have the receipts to prove the machine isn’t enough on its own. When we ran an automated translation pass over the whole deck, it confidently mistranslated entire verb families, confused Georgian’s noun-and-verb twins, and flagged correct cards as wrong. Useful, fallible, and exactly the kind of error a learner would never catch.

So a native Georgian speaker reviews the content, the Georgian text, the translation, the example sentences, through a purpose-built tool that lets them correct or flag any card. That review covers the language on the card. It’s a separate thing from the synthesised audio, and we don’t blur the two. The system does the heavy lifting at scale; a person makes sure the Georgian is actually right. Rigorous method, human language. That’s the whole bet.