Rènshi · 认识

Thirty-seven hours after insulting Quizlet, I have a live system with eleven thousand terms, synchronized live voting, smart sentence rotation, a hardened test environment, its own name and a subdomain up and running.

The small print: no real student has voted yet, no native eye has certified that the Chinese isn't an automated delirium, and my teacher doesn't even know this screen exists.

Everything that could be programmed alone is done. The only thing missing is the only thing that's scary: reality.

A syllabus organized by academic levels is good for padding a résumé or passing a formal exam. To survive on the street, what works is real situations.

I built ten themed survival templates: ordering food, haggling while shopping, getting around on transport, hospitals, daily life, travel, the office, technology, culture and the environment. That's 337 strategic words, most for daily combat and a handful for advanced rescue. The teacher clones the set with one click and fits it to her class.

Nobody asks for the check in a Chinese restaurant mentally calculating which level 2 grammar applies.

The project had been dragging along the provisional name Hanzi, which literally means "Chinese characters". It's the intellectual equivalent of naming a Spanish app "Letters". Zero poetic effort.

Now it's called Rènshi (认识): to know, to recognize. Precisely the word from Quizlet's infamous handshake that set off this whole drama. New domain, new logo, new title: renshi.davila.uno, with the old one redirecting into exile.

The poetic irony: the search box had been using "renshi" as filler text in its pinyin examples for days. The app knew what it wanted to be called long before the penny dropped for me.

With the avalanche of the new catalog, 9,900 words were left orphaned without sentences. And my original dogma was ruthless: no contextual sentences, no card. Consequence: 90% of the new dictionary was censored under lock and key.

I had to swallow my pride and rewrite the rules. Now words without sentences show up anyway, but the back of the card passes the ball to the class: "Make up a sentence with this word. Say it out loud; the teacher will correct it."

What was born as a desperate patch to cover a hole ended up being the best teaching call of the week. Using a word under pressure teaches ten times more than staring at it in silence.

I opened the floodgates to the rest of the official syllabus: HSK 4 all the way to 9. The database ballooned from a thousand to eleven thousand terms.

The editor and the admin panel, innocent as they were, tried to download the entire dictionary into the browser to filter on the client. With a thousand words the machine didn't complain; with eleven thousand, smoke nearly came out of the processor. Now the search happens where it should —in the database— and only what was asked for travels to the browser.

What works at toy scale isn't robust: you just haven't given it a reason to break yet.

The input for entering the code was a plain old text field. If the student was missing a single character, they had no way of knowing until they submitted the form and got a generic error on screen. Zero clues.

I redesigned it into six individual boxes: if a letter is missing, the gap screams at you from the screen. I also got the vote to dance to the rhythm of the slide: the teacher moves to the next character and the students' screens rotate automatically.

Along the way a farcical bug popped up: a straggling request asking "is the vote still active?" arrived late and switched the vote off on the teacher right after she had switched it on with the V key. Pure cinema.

All thousand senses now have their Spanish translation, and we raked through over two thousand example sentences, a mix of public databases and synthetic brainchildren of artificial intelligences.

The junk that surfaced was museum-worthy: Latin names shoehorned into the middle of imperial dynasties, pronouns with the gender flipped, sentences with an expiration date and prices in dollars where the Mandarin text talked about yuan.

None of it was marked as verified. One language model grading another language model's homework is a circular joke. The final sign-off comes from a human brain that speaks Chinese, or nobody signs it.

I sent the interface off to be audited and the report came back with a condescending "nothing serious". I ordered a second pass immediately: in software, "nothing serious" is usually an impending disaster in disguise.

Two beauties turned up. If the classroom WiFi drops —which happens in 100% of the world's schools— the student's screen was left with endless ellipsis dots, leaving them with the existential doubt of whether the internet died or the teacher fell asleep. The other: the Spanish screen reader read the character 家 as "ya" (Spanish for "already!") instead of jiā.

The first audit wasn't bad; it just wasn't in the mood to work.

Until today, my testing method consisted of throwing code straight at the production database. A fascinating technique, equivalent to crossing a highway blindfolded because "nobody has run me over so far".

I created a second, cloned database exclusively for breaking things in peace. Sentence rotation and the voting system sweated it out there first: eight suites in green, a safety backup, and only then the jump to production. My first officially non-suicidal version.

Charming detail of the ecosystem: PowerShell decided to swallow a couple of dashes in the terminal and the tests happily ran against the wrong database without throwing a single error. Such a delight, working on Windows.

The "How it's built" section swore, cool as anything, that 爱 ("love") was a simple character. Spoiler: it's not even close. The app claimed it simply because it had no data, and faced with the void it preferred to lie with absolute confidence rather than admit ignorance. Very human of it.

Content martial law: if there's no rock-solid data, the card keeps its mouth shut. After several drafts, the formula was stripped to the bare chassis: just the pieces with their pinyin underneath (知 = 矢 + 口), without making up fables.

I took to my own creature the same chainsaw I took to Quizlet. A silent card teaches little, but a chatty card misinforms.

The anonymous vote —the one I swore yesterday afternoon I'd leave "for a second phase"— is alive and kicking.

Mid-lesson, the teacher hits the V key, the screen shows a code and students vote from their phones without creating an account, without giving an email and without leaving a trace. They see the character and the pinyin (the meaning well hidden, obviously) and can change their answer if panic makes them change their mind. She watches the tide of votes in real time with a merciless traffic light that reveals whether the class got it or everyone's on the moon.

The hell wasn't the interface: it was allowing a total stranger with no session to write to my database without handing them the deeds to the server.

If every class shows exactly the same two sentences per card, by the third session students aren't reading characters anymore: they're singing the chorus from memory like trained parrots.

Now the teacher decides how many sentences to show and the app shuffles them with some sense: first the ones that group hasn't seen yet, then the ones gathering dust in oblivion. The sentences she writes by hand go into the roulette on equal terms.

Repeating the character is learning; repeating the identical sentence is karaoke.

The collections screen stayed blank for over a second, staring at nothing. Doesn't sound dramatic until you picture twenty students silently staring at you in the middle of a Zoom class.

The diagnosis was a geography joke: the app ran in a data center in Virginia and the database was sleeping peacefully in São Paulo. Every query had to travel from Lima to the United States, go down to Brazil and bounce back. A continental tour for every click.

I moved the app to São Paulo, stopped pulling the full text of 68 lessons just to count how many there were, and added a loading skeleton to save face. It dropped from 1.3 to 0.5 seconds. Half the optimization was simply respecting the world map.

To test the protected screens, the lazy shortcut was to hand my password to whichever agent was on duty. No way. I'm paranoid, yes, but with good reason: giving credentials to an AI is the modern version of leaving the key in the outside of the door and hoping nobody turns it.

I applied some judgment: I log in once, the session stays warm on my machine, and the automated tests ride on that cookie without anyone having to see my passwords.

In the prototype everything was glamour: a thousand senses perfectly broken down, with magazine-grade grammatical categories. When I plugged it into the real database, the glamour turned into a barren wasteland with cryptic labels in abbreviated Chinese like «量、（名）».

I found the trick: the mockup read from a loose, lovingly crafted file that nobody ever bothered to migrate to the real tables. The pretty stuff lived in the local fantasy; the database had barely a scrawny skeleton.

An emergency migration plugged the holes. Eleven words are still floating in limbo with no meaning because the original source didn't have them either, and Spanish —the banner of this whole crusade— got postponed until there's oxygen.

Ten words are enough to impress in a presentation. For learning a language they won't even get you a glass of water.

At that hour of the morning I plugged in the official HSK 3.0 syllabus (levels 1 to 3) and the app mutated into another species. The teacher who uses this no longer has to start from scratch: she grabs a template from the syllabus, tweaks it to taste, done. The collections are hers; the core base is only touched by the supreme administrator (me).

I stopped having a flirty demo to win over skeptics and started having a tool someone could use on a Tuesday at 8 a.m. And that is genuinely terrifying.

I created the subdomain. Vercel looked at it, said "yes, verified", crossed its arms and refused to issue the SSL certificate out of sheer apathy. Verified, yes; secure, not a chance. I had to go beg for the little padlock by hand, like it was paperwork at city hall.

The other gem: the app reached production alive before it occurred to me to test the login with my own account. I tested it straight in production, like the brave or the reckless do. Miraculously, nothing blew up.

At three in the afternoon it was a childish tantrum against Quizlet. At eleven at night it's a working monster with authentication, ten words loaded, cards that flip and an operational database.

Minor detail of no importance: no real user has touched it, my teacher has no idea this exists, and I never tested it while screen sharing on Zoom, which was supposedly the whole point of this circus.

Seven and a half hours burning tokens. The code is ready; all that's left is the terrifying part: showing it to her and praying she doesn't send me back to studying on Quizlet.

The back of the card was still missing. I flatly refused to put photos in: the generic handshake of 认识 is this project's sworn enemy. And glyphs generated by an AI hallucinating strokes, don't even get me started.

We went to the millennia-old source: real ancient forms, oracle bones and bronze, but only when the character tells a genuine visual joke. 家 is literally a pig sleeping under a roof; that teaches you more history and context than any smiling Shutterstock model.

If the drawing doesn't help you remember the stroke, it goes straight in the trash.

There was a peak moment of delirium when four AI agents were operating on the same folder: one Claude hammering out code, another Claude trying to deploy to Vercel and Codex running a moral audit, with Cline snooping on how the others worked so it could crack the whip and "correct" them.

One switched Git branches, another ran a treacherous npm install, and the server collapsed in the middle of the third one's analysis. The audit died on the spot. Nobody was to blame, but four artificial intelligences squeezed into the same terminal are as efficient as four people trying to drive with the same steering wheel.

Golden rule: each agent in its own pen. Adding helpers only multiplies the chaos if they all sit in the same chair.

I spent a good while doubting my own sanity because I'd change styles in the code and the screen stayed exactly the same. Reload, pray, nothing.

The dev server kept a disk cache so stubborn it survived restarts and kept showing me the old version with a mocking smile. Minutes earlier, the character strokes had vanished entirely: a color trick the compiler decided to ignore in absolute silence, without a single miserable error in the console.

The first attempt at dark mode was an aesthetic tragedy: 1970s government-office-furniture brown. Depression in CSS.

I set up a golden palette in parallel to compare corpses. The winner, by a landslide: a cold charcoal background bordering on the existential void, cream text and gold details. Then the obsessive touch: in the dark, the character's ink dims toward the radical instead of lighting up, because the idea is for them to learn Chinese, not go blind staring at a neon sign.

Putting the two screens side by side ended the discussion faster than any philosophical debate about design.

I had the brilliant idea of making the interface Chinese by default because "the teachers are native speakers". I held that conviction for exactly 240 seconds.

The first person to open this abomination is me, and after that any curious visitor who probably can't tell an ideogram from a ramen noodle. Now the app sniffs the browser language: Chinese, Spanish or English, with a manual selector for the nonconformists.

The untouchable part: cards go in the student's language, not in the language of whoever projects the screen. It took me half an afternoon to grasp that obvious fact, but let's pretend it was always part of the plan.

I politely told the browser the page was in Chinese. Chrome, with its signature arrogance, decided I needed its charity and translated the whole thing without asking.

Brilliant result: 汉字 became "Chinese character". On a platform designed specifically to learn to decipher Chinese characters, the browser took care of erasing every one of them.

Now the code includes an explicit order for Chrome to keep its hands in its pockets and touch nothing. It's the only line in the whole app written to tame an insolent machine.

The first version of the card was a rainbow throw-up: the radical in one color, the phonetic part in another, the key word in fluorescent red. Very educational, they said. It looked like the control panel at Chernobyl.

I declared visual martial law: one color, one meaning. Soft red is strictly confiscated for the key word in context. On the front, the character goes sober in Chinese ink and the radical barely breathes in a subtle tone. The color-coded explanations of how the monster was assembled move to the back, where nobody gets hurt.

If everything shouts at once, nobody hears a damn thing.

I put together ten words, thirty test sentences and a vigilante validator to keep a beginner from ending up reading mastery-level hieroglyphs.

I ran the script with my chest puffed out in pride, and the first thing it spat in my face was 厕所 ("bathroom"), a level 5 word smuggled into a level 2 sentence. And 过, which I swore was kindergarten stuff, turns out to be level 4 in the new exam.

I built a detector for other people's ignorance and the first thing it detected was mine. Poetic.

My master plan lasted exactly two hours: it started as a solitary app for studying while I cry over my notes, and by the afternoon it was an interactive circus.

It dawned on me that this demo isn't here to save me: it's here to hypnotize my teacher and show her, live, how a class should feel. The center is now the classroom: presentation mode for screen sharing on Zoom, a real-time understanding thermometer and, later on, an anonymous Kahoot-style vote to take the group's pulse without exposing anyone.

Self-study is still there, but on the waiting list. First the spell has to work in the classroom; the spaced repetition algorithm can wait its turn.

The app's unit isn't the word. It's the sense.

Each use of a character goes in its own lesson and is measured separately. If I cram them all onto the same card, I'm back to the Quizlet problem with extra steps.

With Nimbus I already had Vue and Firebase down with my eyes closed. What does a sensible person do? Use what works. What did I do? Exactly: send it all to hell and use something different: Next.js with Supabase.

Because sure, why finish fast when you can complicate your life learning a new stack on its own subdomain? I needed a login for teachers and a real database, but above all I needed to remind myself that I don't know how to live in peace.

From Nimbus I brought the only truly valuable thing: the complete catalog of every mistake that has already cost me tears.

At three in the afternoon I had a complaint and a hypothesis. The complaint: my teacher's Quizlet cards translate word for word, and Chinese won't have it. The hypothesis: a word makes more sense inside a sentence than alone on a card.

Not a new idea. What's new is that this time I got to suffer it as a student.