Tongue is an open source language learning system I built on top of Claude Code. Instead of a traditional app, it’s a set of Markdown protocols that transform Claude into a personalized language tutor with memory across sessions. It’s free to fork, customize, and make your own. I can’t overstate how blown away I have been by this. I studied Spanish 5th-12th grade, Japanese in university, lived in Japan while studying Japanese at an intensive language school, moved to Mexico and picked spanish back up through private tutors and a course at a university, I have been an avid user of Anki. None of those things have lead to the rate of progress I have seen with this system. It is like a genius private tutor that knows exactly what you struggle with and creates on the fly exercises to target those weaknesses. I hate that it is impossible to not sound like you are overhyping the thing because AI is just that insane, but honestly I can’t imagine how it could be better.

Table of Contents

How It Works

When you open the project in Claude Code, a boot sequence kicks in. It reads your configuration, loads your progress from JSON tracking files, checks what’s due for review, and presents you with session options — all before saying a word. The result is a tutor that picks up exactly where you left off.

There are (currently)three session types:

  • Full Session (30-40 min) — Spaced repetition review, new material, and conversation practice
  • Quick Review (10 min) — Focused review of items due for repetition
  • New Concept (15 min) — Deep dive into one grammar or vocabulary concept

The system suggests which type to run based on your current state. Many overdue items? It nudges you toward a Quick Review. Curriculum has untaught material? It suggests New Concept. But you can always choose whatever you feel like. The tutor adapts to your choice, not the other way around and you can come up with your own session types and protocols if you want just by asking for them. The sky is the limit.

Spaced Repetition

All vocabulary, grammar, and morphology are tracked in JSON files with a confidence scale from 1 to 5, mapped to review intervals (1 day → 2 → 4 → 8 → 16). Items graduate after reaching confidence 5 with three consecutive correct recalls. Failed items get demoted, not reset — the system respects what you’ve already learned.

Review isn’t just flashcards. It varies the retrieval path: translation both directions, fill-in-the-blank, contextual usage, morphology checks, and error correction. This prevents shallow pattern matching and builds real fluency.

Language Agnostic

The core protocols work for any language. Spanish, Japanese, Arabic, Mandarin — the system reads your config and adapts everything: keyboard/IME setup, script handling, morphology tracking for inflected languages, tone practice for tonal languages, and culturally grounded examples based on your actual location and daily life.

Teaching Approach

The tutor follows modern second-language acquisition pedagogy. Grammar is taught through usage, not tables. Errors are corrected through natural recasting — the tutor rephrases what you said correctly without interrupting the flow. Explicit explanations only come in for recurring patterns.

Sessions enforce pacing guardrails: at least 30% review, at least 40% conversation, and no more than 30% explicit instruction. New vocabulary is capped at 3-5 items per session. Quality over quantity.

Customization

Because Tongue is just Markdown and JSON, everything is customizable. And because it runs in Claude Code, you can literally ask your tutor for anything and it can build it for you on the spot.

Here are some ideas from how I’ve been using it to learn Spanish in Mexico City:

Use your life as the curriculum. I wrote out my story of how I ended up living in Mexico and told the tutor to use it as the backbone of the curriculum. Instead of learning grammar through textbook sentences, I’m learning it by telling my own story — how I arrived, met my wife, had a motorcycle accident, moved to the city. The vocabulary and grammar I need shows up naturally because it’s attached to things I actually want to say.

Set real goals, not abstract ones. My wife and I read books together and discuss them. I told the tutor that being able to hold my own in those discussions was the goal. So the curriculum builds toward abstract vocabulary and opinion structures — discourse markers like “o sea” and “por un lado… por otro lado,” subjunctive for expressing doubt and hypotheticals — because that’s what I actually need.

Ask for games. One session I asked the tutor to create a “unique way to review what I had learned”. It created a Lotería-style vocabulary review. It dealt cards, I had to recall the meaning, and grammar concepts showed up as bonus rounds. Scored 108 puntos. The tutor can invent whatever review format sounds fun to you.

Lotería de Español home screenLotería de Español game board

Customize the dialect. I told the tutor I live in CDMX and want Mexican Spanish. It uses tú instead of vosotros, teaches mexicanismos like chamba, neta, and ahorita, and grounds examples in daily life here — the metro, fondas, tianguis, trámites. Whatever dialect you’re immersed in, tell the tutor and it will match.

The point is: this isn’t a rigid system. It’s a starting point. Ask the tutor to create reference sheets, invent exercises, change the teaching style, focus on a specific weakness, or do something no language app has ever done. It’s Claude — it can do whatever you need.

The Design Decision

I never would have come up with this if it weren’t for Tasshin and his Mentor system. Seeing him use Claude Code as the runtime for something personal and stateful — not an app, just protocols and files — completely reframed what I thought was possible. Tongue is that idea applied to language learning.

I could have built an app. But the interesting constraint was: what if the runtime is just Claude and the file system? The protocols are Markdown. The data is JSON. The intelligence is Claude’s conversational ability. No database, no backend, no dependencies.

This means the entire system is version-controllable, forkable, and readable. You can open any file and understand exactly what the tutor will do. And because it runs in Claude Code, you get a language tutor inside the same environment where you’re already working.

Getting Started

Tongue runs inside Claude Code, Anthropic’s CLI for Claude. Here’s what you need:

  1. Install Claude Code — Follow the setup guide at claude.ai/code to install the CLI.
  2. Install VS Code — Download it from code.visualstudio.com. Claude Code works in VS Code’s terminal or as a standalone CLI.
  3. Set up Git and GitHub — If you’re new to Git, GitHub’s guide will walk you through installation and configuration: docs.github.com/en/get-started.
  4. Clone the repo — Open your terminal and run:
git clone https://github.com/presfunkmann/tongue.git
  1. Open the project in Claude Code — Navigate into the cloned folder and start Claude Code. The boot sequence will walk you through configuration from there.

I’m on the Claude Max plan ($100/mo), which gives plenty of headroom for daily sessions. The cheapest plan should work fine for core tutoring — conversation, review, and tracking. Where you might hit limits is if you ask Claude to generate something ambitious like the Lotería game, which involves writing a full interactive app from scratch. But for the actual language learning, any plan should do.

Tongue is open source under the MIT license. Fork it, change anything, make it yours.

View on GitHub →