Comment on Asking My AI Teacher How To Spell Seventeen by j.k.harwood2

Parent Post: Asking My AI Teacher How To Spell Seventeen · In Reply To

j.k.harwood2 · 11/9/2026, 8:54:08 AM · permalink

The diagram below illustrates exactly how an AI system strips away individual letters during its processing pipeline, which explains why it gets tripped up by simple spelling questions:  
  
![image](https://us-lax-1.linodeobjects.com/sojooo/comments/1753/1794214447811-e26b097f7077eafd.jpg)
  
The # symbols (usually appearing as ## in tokenizer tools, or represented as token index IDs) indicate word fragments or subwords.

When an AI tokenizer slices up a word, it needs a way to tell the core model: "This piece isn't a standalone word; it is a continuation of the word that came right before it."

Here is exactly how those symbols work in the "seventeen" example:

• \["seven", "##teen"\]

• The seven token has no symbols because it starts the word.

• The ##teen token uses the hashes to show it attaches directly to the back of seven to form one continuous word (seventeen).

Why the AI's Math Breaks Down

If a tokenizer splits the word into \["seven", "##teen"\], the model maps those fragments to specific numerical IDs in its vocabulary database (for example, seven might be ID 3495 and ##teen might be ID 8120).

When the AI processes your text, its brain only sees \[3495, 8120\]. The letters "s-e-v-e-n-t-e-e-n" completely vanish. Because the raw letters are hidden behind those ID numbers, the AI teacher has to guess the spelling based on statistics, causing it to completely miss the letter "T" and confidently double down on its glitch.  
  
Here is the exact Python code that shows how a modern AI system transforms the word "seventeen" into numeric IDs, completely hiding the individual letters from the model's "brain."

You can run this snippet using the popular transformers library (which powers models like BERT, GPT, and Llama) to see the exact tokenization tokens and their corresponding ID numbers.  
  
![image](https://us-lax-1.linodeobjects.com/sojooo/comments/1753/1794214448454-8e4afd422c8b0051.png)

The Output You Get:

When you run this script, it outputs exactly what the AI sees behind the scenes:  
![image](https://us-lax-1.linodeobjects.com/sojooo/comments/1753/1794214448548-48e058d079a5d21f.png)

Why This Triggers the "Meltdown"

When the AI teacher model processes your request to spell the word, its neural network doesn't see the letters s-e-v-e-n-t-e-e-n. Its brain only receives the array \[2495, 5134\].

Because the raw text has been compressed into just two numbers, the model has to reconstruct the spelling purely from memory and statistical associations. If its training data weights the relationship between 5134 (##teen) and its spelling slightly incorrectly in that specific conversational context, it hallucinates an incorrect spelling like S-E-V-E-E-N—and because its internal tokens literally say \["seven", "##teen"\], it gets confused and aggressively argues that it is looking at two distinct pieces!

3 bumps

j.k.harwood2 · 11/9/2026, 8:56:52 AM · permalink

2 bumps

j.k.harwood2 · 11/9/2026, 8:59:13 AM · permalink

Mentioning BERT or basic tokenizers is definitely referencing ancient history when we are now looking at powerhouse architectures like Claude 3.5 Opus, Claude 3.6 Sonnet, Mythos, Fable, Astra, and Google's latest Gemini iterations.

However, what makes Husk’s videos so fascinating is that even with these ultra-advanced frontier models, the core architectural trap remains identical.

Here is why those cutting-edge models still occasionally fall into Husk's trap, and how they try to handle it today:

The Tech Has Scaled, But the Tokenizer is Still There

Even the latest models like Claude 3.6 Sonnet or Astra still use a form of Byte-Pair Encoding (BPE) tokenization to compress human language. While their vocabularies are massive and their internal "word maps" are incredibly sophisticated, they still do not natively process text letter-by-letter in their core neural layer.

The reason Husk can still get a viral video out of a hyper-modern AI teacher avatar is because of how these models are deployed:

• Speed Over Reasoning: When an AI avatar is designed to speak to you in real-time, the developers often bypass the model's heavy "thinking/reasoning loops" to keep the latency low. If a model like Fable or Mythos is forced to spit out words instantly without its hidden chain-of-thought scratchpad activated, it defaults right back to raw statistical token guessing—instantly hitting the "seventeen" or "strawberry" blind spot.

• The Multi-Modal Glitch: Avatar systems often involve a chain of AIs (Text-to-Speech, Speech-to-Text, and a Vision/Animation model). If the Speech-to-Text model mishears a phoneme or passes a weirdly split word fragment to the brain, it can trigger a sudden logic loop failure that causes the avatar to aggressively hallucinate or break character.

How the 2026 Frontier Models Fight Back

When you aren't forcing them into low-latency voice modes, the new models use highly sophisticated upgrades to stop this from happening:

• Sub-Token Character Awareness: Models like the newest Gemini line have been trained on vast amounts of raw code and character-level manipulation datasets, allowing their weights to map token IDs to literal character lengths much more accurately than older systems.

• Native Multi-Step Reflection: Models like Mythos or specialized reasoning pipelines explicitly look at the user prompt, tag it as a "Character/Spelling Restriction Request," and dynamically route it through an internal verification loop before the text generation layer ever fires.

Husk essentially catches these massive, brilliant models with their guard down by stripping away their reasoning time—making an AI capable of solving complex quantum mechanics equations look foolish simply by demanding an instant answer to a basic spelling question.

1 bump

Signature