Speak First, Learn Second: Building an Antifragile Spanish Engine
Everything about how we teach languages is backwards. Study, memorize, practice, then maybe speak. I built a system that reverses the order: speak under pressure first, log what breaks, drill the friction, speak again. No app. No gamification. Just markdown files, agent prompts, and real people.
Speak First, Learn Second: Building an Antifragile Spanish Engine
The McDonald's Realization
Walk into any restaurant in Nevada, any fast food counter, any shop in the Southwest, and Spanish is everywhere. In the kitchen, behind the counter, in the parking lot. Warm and fast and communal in a way English rarely is at work.
The crew speaks Spanish to each other. Fast, overlapping, easy. Jokes I can't follow. Orders called back in a rhythm that sounds like music if you can't parse the words. They switch to English when I reach the counter, and something deflates. A door closes that was briefly open.
I've been standing at those counters for years. Nodding. Smiling. Saying gracias with the confidence of someone who knows exactly one word well.
Spanish is the most practically useful second language you can learn in the United States. The workforce, the neighborhoods, the restaurants, the service industries: most of the Southwest runs on it. The people are there, they're warm, and they'll meet you halfway if you make the attempt. The gap isn't cultural. It's just capability.
Something had to change.
Why Every Language App Is Wrong
Here's what Duolingo and its descendants get you: recognition. You can match pictures to words. You can tap the right translation. You can maintain a streak that means absolutely nothing when someone at the counter says ¿Qué va a querer? at natural speed and your brain locks up.
The gap between recognizing a word on a screen and producing it under pressure is the gap between knowing how to swim and being thrown in a lake. McDougall made the same argument about running: cushioned shoes remove the feedback signal. Protection creates fragility.
Every traditional method follows the same sequence: study vocabulary, learn grammar rules, practice exercises, then eventually try speaking. The speaking part is treated as the final exam, the thing you do after you've prepared sufficiently. After you're ready.
You're never ready. That's the trap.
I spent years in the software industry watching this same pattern destroy projects. Teams that plan forever and ship never. The ones that win are the ones that deploy early, observe what breaks, fix the specific thing that broke, and redeploy. DevOps taught me that. Nassim Taleb taught me the deeper principle: systems that encounter controlled stress get stronger. Systems that avoid stress get fragile.
The word for that is antifragile. And it applies to language learning as much as it applies to trading or software.
The Architecture
So I built something. Not an app. Not a platform. A system made of plain text files and AI agent prompts that reverses the traditional order completely.
I call it Velocidad.
The core hypothesis is simple: speed to conversational Spanish comes from production pressure, not comprehension study. You speak first. You fail. You log what broke. You drill the friction. You speak again.
The daily engine runs in 25 to 30 minutes:
Speak First (5-7 minutes). An AI agent plays the role of a McDonald's cashier, or a house worker, or a neighbor, or a coworker. Full Spanish. No prep. No vocabulary review. Just: go. If I freeze, I have to use repair phrases to recover. Perdón, ¿puede repetir? If I switch to English, the agent gently pushes me back. The discomfort is the point. The discomfort is the learning signal.
Extract Friction (3 minutes). Immediately after the session, while the memory is fresh: what couldn't I say? What didn't I understand? What errors keep repeating? What sounds am I butchering? What structures am I avoiding? This gets logged as structured data. Not vague feelings. Specific gaps.
Targeted Micro-Drills (7-10 minutes). Ten production reps targeting exactly what broke. Five repair reps for freeze-recovery. Five variations that take today's pattern and swap the nouns. Everything is generated from the friction, not from a textbook.
Shadowing (5 minutes). Native audio. Listen once, then shadow it three times. Mouth muscle memory matters. You can understand a phrase intellectually and still stumble over it physically.
Micro-Deploy (optional but critical). One real interaction. Even twenty seconds counts. An entry line, a goal, an exit line. Hola, buenos días. Quiero un número cinco, por favor. Gracias, que tengan buen día. Done. That's a deployment. That single real exchange hardened more vocabulary than an hour of flashcards ever would.
The framing comes straight from DevOps. Speaking is your production environment. Roleplay with the AI is staging. Drills alone are development. You don't deploy untested code to production, but you also don't stage for months without shipping. Every week, you push to real humans. Even twenty seconds is a production deployment.
The System Thinks in Worlds, Not Lessons
Traditional methods organize around topics: food vocabulary, colors, body parts. Abstract categories divorced from any context that matters. Velocidad organizes around worlds. Real places, real people, real scenarios I'll encounter within 48 hours.
McDonald's is the safe lab. Low stakes, high warmth. The crew knows me. The order flow repeats. I go there already. The scenario ladder starts at L1 (ordering only, thirty seconds of Spanish) and climbs to L5 (full conversation, joking, handling interruptions).
Casa is for house workers. Directions, logistics, appreciation. Puede mover esto a la izquierda. Higher stakes because misunderstanding means actual consequences.
Vecinos is my neighbor and his family. Real friendship being built across a language gap. Small talk, plans, kids, neighborhood life.
Errands is everywhere else. Restaurants, shops, the daily fabric of a bilingual city.
One world per week. Go deep, not wide. Patterns compound across contexts. The quiero template from the coffee order carries into every other world.
Reverse-Engineering the Machine
I'm a systems thinker. I reverse-engineer machines for a living. So I did the same thing to Spanish.
The language architecture document in my system decomposes Spanish into layers the way you'd decompose a software system. Layer 1 is the Sound System, the I/O. Five vowels, each making exactly one sound, always. Spanish has the most predictable sound system of any major European language. If you can read it, you can say it. Period.
Layer 4 is the Verb Engine, the CPU. Spanish front-loads information into the verb. Who did it, when, what mood. English distributes that across helper words and pronouns. Once you internalize verb endings, Spanish becomes more compact and faster to produce than English.
Layer 10 is the Repair System, error handling. Eight phrases that keep you in the conversation when everything else fails. No entiendo. Más despacio, por favor. Perdón, ¿qué dijo? These are memorized cold, drilled until they're automatic, because they're your safety net. Without them, one moment of confusion sends you crashing back to English. With them, confusion becomes a conversation move.
I call it the pattern genome. Spanish is not ten thousand words to memorize. It is a combinatorics problem. The pattern Quiero + thing generates: Quiero un café. Quiero agua. Quiero el número cinco. Quiero aprender. Quiero decir que... One template, dozens of sentences, all running on the same engine. You master the template, not the words. The words are swappable arguments.
I'm not learning Spanish the way a student learns Spanish. I'm learning it the way an engineer reverse-engineers a runtime. See the machine, understand the instruction set, then generate output.
The Agent as Sparring Partner
The entire system runs through AI agent mode. No app to install. No account to create. I paste a master prompt into the agent, tell it which world to run, and the session unfolds.
The agent plays the NPC. In McDonald's, it's a crew member who speaks at i+1, comprehensible input slightly above my level. It waits for my response after each line. It forces moments where I have to recover. It escalates difficulty within the session if I'm handling it. It always ends with a successful exchange, a win, because you never end on failure.
After the session, the same agent distills the friction. It extracts chunks, the short speakable phrases I should harden. It extracts patterns, the reusable sentence templates. Quiero + thing. ¿Puede + verb? ¿Tiene + noun? Master eight patterns and you can express 80% of survival-level communication.
Then it generates drills targeting exactly what I got wrong. Not generic exercises. Precision strikes on the gaps that actually showed up.
Then it observes the meta. What technique worked? What caused hesitation? Any breakthroughs? It updates a learning observations file. The system literally watches how I learn and adjusts itself.
The first real session ran February 19th. McDonald's, level one. Afterward the agent logged the exact errors: gender agreement tripped me (muchos gracias instead of muchas), fast number phrases were incomprehensible, I avoided all small talk and stayed inside the transaction. It also noted something useful: my German fluency is an advantage. Verb conjugation frameworks and gender systems transfer directly. Within hours the system had generated a personalized reference folder built around Spanish-German bridges. Not generic content. Targeted material from what actually broke that day. That's not a static curriculum. That's reactive intelligence.
Six prompts. Markdown files for data. A four-box SRS system for spaced repetition. No dashboards. No gamification. No progress trees. The only metric that matters is written at the top of the scorecard: Did Joshua speak more Spanish to real people this week than last week?
Friction Is the Curriculum
The hardest part to trust: there is no curriculum. No week-by-week syllabus.
Friction is the curriculum.
Whatever broke in today's session becomes tomorrow's drill. Whatever I avoided becomes next week's focus. Whatever I got right gets compounded into harder scenarios. The system doesn't teach Spanish. It teaches my Spanish. The specific Spanish I need for the specific people I talk to in the specific places I go.
Grammar is debugging, not coursework. I don't study verb conjugation tables and then try to use them. I try to say something, get the conjugation wrong, log the error, and drill the correction. The grammar arrives as a fix for a specific failure, not as abstract knowledge waiting to be applied.
This is the antifragile principle in practice. Controlled stress creates adaptation. Biologists call it hormesis. The dose that doesn't kill you makes you stronger. A phrase forged in the friction of trying and failing sticks ten times harder than one memorized from a list.
The Payoff
There's a line in my learner profile: I am someone who operates in Spanish. Not "learning." Operating.
That distinction matters. Learning implies a destination you haven't reached. Operating implies you're already doing it, just getting better. The people you want to talk to don't care if your conjugations are perfect. They're not waiting for you to be fluent.
Most people who want to learn Spanish already live or work around it. The opportunity is there every day. The gap isn't access or motivation. It's just the willingness to be bad at it in public, on purpose, until you're not.
Speak first. Learn second. Deploy daily. Even twenty seconds.
The system is not the goal. Speaking Spanish to real people is the goal.
The Confession
I've built systems my whole life. I can almost feel you thinking: he's over-engineering it again.
And you might be right. The design document runs long. The language architecture has fourteen layers. There are six agent prompts and a four-box SRS system and structured friction logs in JSON.
But here's the rule written at the top of the rules of immersion:
If more than 10 minutes pass without speaking Spanish, something is wrong.
The system exists to serve the speaking. The moment it becomes overhead, you delete whatever's causing the overhead and go talk to someone. The anti-pattern is right there, hard-coded: no system-building as procrastination.
I build things just enough to be useful. Not overbuilt, not underbuilt. Functional enough to start a life of its own. That's what happened here. The system exists, it runs, and now it just needs to be used. The rest will evolve from actual sessions, actual friction, actual people.
¿Y Ahora Qué?
The system is initialized. The worlds are built. The prompts are written. The chunk bank has its first entries. The pattern bank has its first templates. The metrics scorecard is empty, waiting for data.
Now comes the only part that matters.
Hola, buenos días. Quiero un número cinco, por favor.
Thirty seconds. That's all it takes to start.
Everything else is just friction, waiting to become fuel.
The system is plain text all the way down. No dependencies. No accounts. Just markdown, prompts, and the willingness to sound stupid in public.
That's where all real learning begins.