Learning Arabic with AI: how the tutor actually works

Getting a language model to speak Egyptian Arabic takes about an afternoon. Getting a beginner to survive four turns of that conversation took considerably longer, and almost none of the work was in the model.

A raw chat window fails a beginner twice, in a specific order. First they can't read the reply — it comes back as unvowelled Arabic script, and even a learner who knows the alphabet is now doing archaeology instead of talking. Then, once that's solved, they hit the wall that actually ends conversations: they understand the question perfectly and have no idea how to answer it. They know maybe two hundred words. The reply they want to give needs a word they don't have.

Two of our decisions come straight out of those two failures: every tutor message arrives as three lines rather than one, and every turn ends with a suggestion for what you could say next. Here's the reasoning, and the implementation underneath it.

One message, three lines

A tutor turn isn't a string. The model is given a JSON schema it has to fill, and the reply only renders if all of the fields come back:

{
  "arabic":          "أهلاً! تحب قهوة إيه؟",
  "english":         "Welcome! What kind of coffee would you like?",
  "transliteration": "ahlan! tiheb ahwa eh?",
  "wordAlignments":  [ { "arabic": "أهلاً", "english": "welcome", "transliteration": "ahlan" }, … ]
}

Arabic is the thing being learned, and it's always there, always first. English and transliteration exist because they answer different questions, and a learner mid-sentence usually only has one of them.

English answers what does this mean. Transliteration answers how does this come out of my mouth. Those come apart more often than people expect: you can know exactly what تحب قهوة إيه؟ means and still stall on whether that first word is tiheb or tuhib — a distinction that happens to be the whole difference between sounding Egyptian and sounding like a newsreader. Arabic writes three of its vowels and leaves the short ones off, so the script systematically withholds the one thing a speaker needs. Transliteration is not a softer version of the Arabic. It's the missing half of it.

Then there's a fourth field, wordAlignments, which is the one that took the most prompt-wrangling to get reliable: one entry per Arabic word, in order, with the literal gloss rather than a share of the sentence translation. That turns the message into an interlinear text you can scan:

A sentence-level translation tells you the line means "please". The word level tells you that من فضلك is literally "from your kindness", which is the kind of fact that makes a phrase stop being four syllables to memorise. It also lets you find the one word you missed without re-reading everything, which is what beginners actually do with translations.

Why they're toggles

Everything above is also the standard case against transliteration, and it's a fair one: a learner who can read the Latin line will read it first, every time, and never build the reflex of reading the script. We take that seriously — the site's general position is read franco, write Arabic.

So the three lines are independently switchable, with a global default and a per-message override. The per-word gloss, the transliteration line and the full translation each turn on and off, and a message remembers what you did to it while the rest of the thread stays at your default. The intended path is that you turn the transliteration off somewhere around month two and flick it back on for a single confusing message rather than for the whole conversation.

That's the honest framing: the crutch is real, and the alternative — a beginner who can't pronounce anything they're reading — is worse. Making it one tap to remove is better than arguing about which learner is right.

The thing that actually stops people

Reading comprehension is a solvable problem. Production is the one that kills sessions. The tutor asks you something reasonable, you know what it means, and your Arabic runs out. A human tutor handles this without being asked — they feed you the phrase, you repeat it, the conversation keeps moving. In a chat window you just sit there, and then you close the tab.

So after every tutor reply we make a second, separate call for a single suggested next line, with its own prompt whose stated priority isn't correctness or even usefulness. It's momentum:

The MOST IMPORTANT goal: the line must KEEP THE CONVERSATION GOING and give the other speaker a clear reason to reply.

To do that, the suggestion has to do at least one of three things — ask a relevant question back, offer a new detail about you that invites a follow-up, or open the next natural sub-topic for the scenario. And a set of prohibitions that exist because the first version broke all of them:

• No dead ends. "Thanks", "I'm good", "Okay", goodbyes — banned unless the conversation is genuinely wrapping up. A polite closing line is the easiest thing for a model to suggest and it ends the practice session.
• No repeats, no echoes. Don't reuse a line you've already said, and don't hand the tutor's own question back unchanged.
• Blanks, not inventions. If the line needs a name or a place, it comes back with a ___ for you to fill in, rather than the model deciding you're called Sara and live in Maadi.
• Pitched at your level. At A1 and A2 a suggestion is three to eight words and usually a short question, because an open question is the cheapest way for a beginner to keep a turn alive.

It arrives in the same three lines as everything else — Arabic, transliteration, English — with audio, so you can hear it before you attempt it:

The detail I'd defend hardest is what happens when you tap Use. It does not send the message. It switches the composer to text, forces the keyboard to Arabic, and drops the hint's Arabic into the box with the cursor in it. You can send it as-is, or change a word, or delete half of it and write your own ending — and in practice people edit it, because once a sentence is in front of you the hard part is over. Auto-sending would have been one fewer tap and a completely different product: you'd be watching two models talk. The hint is scaffolding, and scaffolding you have to type is the only kind that teaches anything.

Hints have a switch too, and turning them off stops us requesting them at all. The first hint in a scripted scenario isn't even generated — it's the opening student line from the hand-written dialog, so the very first suggestion you ever see is one a human wrote.

Correction happens to your sentence, not the tutor's

A tutor that stops to grade every utterance isn't having a conversation. So when you send a turn, two calls go out at once: one for the tutor's reply, and one that quietly works on what you just said. Your message appears in the thread immediately with the raw transcript, then gets patched in place with its own translation, transliteration, per-word gloss and — if there's anything to say — feedback.

The rule that took the most tuning is when to show you a corrected version of your sentence. A model asked to improve a beginner's Arabic will rewrite it endlessly, because there is always a more natural phrasing, and being handed a better sentence every single turn is demoralising in a way that being ignored is not. So the corrected-sentence field is only allowed to appear for objective errors: a wrong conjugation, a pronoun that doesn't agree, a bad word form. If the sentence is grammatical but a native speaker would have said it differently, the field is left out entirely. Notes about naturalness can live in the feedback panel, which is a pill you can ignore. "Here's what you should have written" cannot be ignored, so it's reserved for cases where you were actually wrong.

Pronunciation scoring in the scripted drills is deliberately dumber: we normalise the Arabic (strip tashkeel, fold the alef and ya variants together) and take an edit distance against the transcript, pass at 60%, and surface a skip button after three attempts. Word-level matching turned out to be far too harsh — a single wrong letter scored zero — and no learner needs a third opinion on their ع before they're allowed to continue.

Level is the most important line in the prompt

Left alone, a language model answers a beginner's four-word question with a confident, idiomatic, four-sentence paragraph. It's good Arabic. It's useless, and it's the single most common way an AI tutor fails: the learner can't parse the reply, so they switch to English, so the practice stops.

The system prompt therefore carries a per-level instruction, marked as overriding every other instruction about length, and says plainly that a reply above the learner's level is a failure even if it's otherwise perfect:

The level comes from your profile, defaults to A1, and is the setting most worth getting right. Everything else in the prompt is advice; this one is a constraint.

What it remembers

Each conversation is stitched to the previous one if you come back within half an hour, so closing the tab mid-session doesn't start you over. Longer-term, the tutor is given a block of context before it answers: your level and why you said you're learning, summaries and topics from your last five sessions, and — the part that matters most — two vocabulary lists pulled from your review deck: words you've already got to a decent mastery level, which it's told to use freely, and words you're currently learning, which it's told to work in.

That's the loop we actually care about. The words you're drilling on flashcards show up in conversation while they're still shaky, and at the end of a session the Arabic from the transcript comes back the other way — every word the tutor used is offered as a card, you untick the ones you don't want, and the rest enter the deck at day zero. Conversation feeds the deck, the deck steers the conversation.

It also accumulates observations — weaknesses, strengths, topics you keep returning to — and a note only gains confidence by being derived again in a later session. One-off guesses stay weak, which is about the right amount of trust to put in a model's read of your grammar.

Speaking, and the latency tax

The composer opens in voice, not text, because the point is speaking. Recording goes to Google's Chirp 3 with a dialect-specific language code — Egyptian gets ar-EG, Levantine ar-LB, MSA ar-SA — and there's a language toggle so you can ask a question in English ("how do I say I'm allergic to nuts") and still get the answer in Arabic. Playback is ElevenLabs with a per-dialect voice, all of them slowed to 0.9, plus a small patch table for words the voices get wrong: the Egyptian إزيك is swapped for its transliteration before synthesis, which is a funny inversion — the Latin spelling exists in the pipeline because it's the only way to make the machine pronounce the Arabic correctly.

All of which is slow, so most of the engineering is latency. The two model calls per turn run in parallel. Database writes are fired without waiting. Your own message is on screen before either call returns. History is truncated hard — six turns for the reply, eight for the hint. And model "thinking" is switched off on the conversational endpoints, both because a structured three-field reply doesn't need reasoning and because with a prompt this heavy the model would occasionally spend its entire output budget thinking and return nothing at all.

There's also more JSON defence than I'd like to admit: markdown fences stripped from responses that were supposed to be raw JSON, control characters escaped, trailing commas repaired, arrays unwrapped when the model returns a list where an object was asked for. And a final check that refuses to render a message whose arabic field starts with a brace — because failing loudly beats printing a JSON blob in an Arabic font.

Where it still falls down

• Dialect drift. Every Arabic model's centre of gravity is Fusha, because that's what's written down. Ask for Egyptian and you will periodically get an MSA sentence with case endings, especially on abstract topics. Naming the dialect in the prompt helps and doesn't fix it; the per-dialect phonology rules we wrote for the lesson generator are the obvious next thing to push into the tutor.
• Transliteration isn't standardised. There's no romanisation table in the code — the model writes the Latin line freehand, and the house style comes mostly from the hand-written scenario dialogs it's seen. So you'll get 3afwan and afwan in the same session. A fixed scheme is the right answer and we haven't shipped it.
• Resumed conversations lose the gloss. We persist the three lines, not the per-word alignment, so reopening an old conversation falls back to splitting on spaces.
• It will tell you your accent is great. Edit distance on a transcript measures whether the recogniser heard roughly the right word, which is not the same as pronouncing it well. Treat the percentage as a progress bar, not a verdict.

The broader honest version: an AI tutor is unmatched at the thing human tutors are worst at, which is being available at 1am for the fifteenth attempt at the same sentence with no social cost. It is not a substitute for a person who will hold you to a schedule, and it doesn't notice when you quit. What it can do is make sure that the reason you stopped wasn't that you didn't know what to say next.

Try it

• The tutor — pick Egyptian, Levantine or MSA, start with a scenario or just say hello.
• Speaking practice — the same speech pipeline, sentence by sentence, without a conversation to hold up.
• Franco Arabic — why the transliteration has digits in it, and why you should only ever read them.