ESL at Work: The System Freezes for Three Seconds

Ryan asks me a question in our sync. Something about the CC toolchain — whether the hermetic approach is on the roadmap or a nice-to-have. I know the answer. I’ve been working on this for two weeks. The PR is open. I have opinions.

Three seconds pass. My mouth does nothing.

Here’s what’s happening behind the three seconds: four processes are fighting for the same CPU. The technical reasoning thread is retrieving the answer. The language thread is trying to assemble an English sentence around it. The social thread is computing whether this is a moment to be definitive or hedging. And the executive function thread — the ADHD one — is trying to remember what the question was, because it already started drifting toward a related but different thought about Bazel’s platform detection.

All four fire at once. Nothing comes out.

Then I say “uh” and produce a sentence that’s grammatically correct but answers a slightly different question than the one Ryan asked. Nobody notices. I notice.

This happens several times a week.

The thing people get wrong

When I describe this to someone who hasn’t lived it, they hear “I need to improve my English.” And they’re not wrong — I am actively improving my English. But the diagnosis is off. Like prescribing rest for a performance bottleneck that’s actually in the network layer.

The bottleneck isn’t vocabulary. I know the words. I’m writing them right now, in English, and you’re reading them fine. The bottleneck is real-time generation under compound cognitive load. It’s the difference between knowing how to cook and running a kitchen during dinner rush. Same skills. Completely different failure mode.

Native speakers generate English the way a compiled program runs — the patterns are already in machine code, the execution is near-instant. I’m interpreting. Every sentence goes through a translation layer that adds maybe 300 milliseconds of latency. In writing, that’s invisible. In a meeting, it’s the difference between contributing and missing the window.

Add the ADHD and ASD on top, and you’re looking at a system that was already running at capacity before you asked it to do simultaneous real-time translation. The ADHD means my working memory is already contested — tracking the conversation, managing turn-taking, suppressing the impulse to chase a tangent. The ASD means social scripts are something I build consciously rather than absorb implicitly, so there’s a whole separate processing layer for “how direct can I be right now” and “was that pause skepticism or just him thinking.”

Four threads. One core. No hyperthreading.

What a workaround looks like

I started building a system. Not intentionally — it accreted over months, one frustrating meeting at a time. But if I describe it now, it has clear components. Like any system that started as duct tape and became architecture.

Conversation scripts. Before any meeting where I need to present or discuss something, I write out the conversation. Not my talking points — the actual conversation, in screenplay format, with other people’s lines included:

RYAN: What about the native code stuff? The CC toolchain?

YOU: Your simpler version works for now. The TODO you left
     for a more hermetic approach — I have that in #22578.
     Is that on the roadmap, or a nice-to-have?

     (if he raises concerns:)
YOU: Fair point. I can write up the detection logic and share
     on Slack before investing more time.

     (if he says it's not a priority:)
YOU: Cool. I'll keep it as a draft then.

The branching matters. A single scripted answer shatters the moment someone asks a follow-up. But if you’ve pre-loaded the two or three likely follow-ups, the conversation becomes pattern matching instead of generation. Pattern matching is cheap. Generation under pressure is where the system crashes.

Voice profiles. I analyzed a two-hour team meeting transcript — from Otter.ai — and built a profile for how each person on my team actually talks. Not what they said. How they said it.

My squad lead hedges everything. “Like,” “I guess,” “kind of” — softening every sentence like he’s afraid the words might bruise someone. Uses “cool” as punctuation between topics. Never confronts directly; redirects with “I want to table this for now.”

Ryan is the opposite. Precise, complete sentences. Explains in a consistent pattern: problem, then mechanism, then implication. Almost no filler words. Pushes back directly — “I just suspect that’s going to be problematic.” Dry humor that lands two seconds after the sentence ends.

Jay always extends, never contradicts. Opens with “I think it might be useful to…” and builds on whatever the previous person said. Data-oriented vocabulary. Signature phrase: “along the same lines.”

Masatoshi: short fragments. Direct answers. Minimal elaboration. If you asked Masatoshi to describe a burning building, he’d say “fire. building. big.”

Why does this matter? Because surprise is expensive. When someone speaks in a way you didn’t predict — unexpected vocabulary, unusual sentence structure, a tone shift you didn’t see coming — your parser has to work harder. But if you already know the scaffolding of how someone talks, you can allocate more processing to the content instead of the language. The voice profiles reduce parse cost. They turn cold comprehension into warm comprehension.

Phrase banks. Categorized by function, not by topic:

The recovery phrases are the most important row in the table. Not because they’re linguistically complex — a child could say “can you repeat that?” The importance is psychological. When your comprehension fails in real-time, there’s a moment of shame — a flash of they’ll know I didn’t understand, they’ll think I’m slow — and that shame adds cognitive load at exactly the moment you can least afford it. Having the recovery phrase pre-loaded short-circuits the shame. You reach for the phrase while your brain catches up. It becomes a normal thing you say, not an admission of failure.

The neurodivergent layer

Here’s the thing that took me a while to see: the scripting system isn’t just an ESL accommodation. It’s a neurodivergent one.

Autistic people build social scripts. That’s not a workaround — it’s a core feature of how many autistic brains navigate social interaction. You observe patterns, codify them, rehearse them, deploy them. The scripts cover things like “how to disagree without causing conflict” and “when it’s your turn to speak” and “what that facial expression probably means.”

Most autistic people do this internally, invisibly, and it’s exhausting. I was already running that process before English entered the picture. The ESL layer just means my scripts now need to cover two dimensions — the social choreography AND the linguistic output — simultaneously.

So when I built the conversation scripting system, I wasn’t inventing something new. I was externalizing a process that was already happening in my head, and extending it to include language. The AI generates the scripts faster than I can write them by hand. But the practice of using scripts — of pre-loading social patterns and running them from memory — that was already my operating system. Long before I moved to America. Long before I wrote a line of code.

The ADHD adds its own flavor. My executive function is unreliable — some days the working memory is spacious, some days it’s a closet. On closet days, tracking a multi-person conversation while also generating English while also managing social awareness is simply too many things. Something drops. Usually it’s the English, because that’s the process with the highest marginal cost.

The scripts reduce that cost. They convert expensive operations — real-time sentence construction, social calibration, uncertainty management — into cheap ones: pattern matching, retrieval, muscle memory. On good days, I barely need them. On bad days, they’re the difference between participating and going mute.

What this isn’t

This isn’t a triumph story. I didn’t overcome anything. The difficulty is ongoing — it was there yesterday, it’ll be there tomorrow, it’ll be there when I’m forty and have lived in the US for two decades. The three-second freeze will probably always be part of my meetings. The system just makes it happen less often, and recoverable when it does.

This isn’t advice. I have no idea if this would work for anyone else. It works for me because it maps to how my specific brain already processes social interaction — externalize, codify, rehearse, deploy. Someone with a different cognitive profile might find the whole thing more exhausting than helpful. I’m a sample size of one.

And this isn’t about AI. The AI makes the system faster to build — it generates scripts in seconds instead of the thirty minutes I used to spend writing them by hand. But the AI is a means. The insight is older and simpler: you can precompute language the same way you precompute anything else. Move the expensive work out of the hot path. Serve from cache at runtime. The tools change. The optimization doesn’t.

What it actually is

It’s a person studying their own brain, finding the bottleneck, and building a workaround.

I know where my system fails: real-time English generation under social-cognitive load. I know the contributing factors: ESL latency, ADHD working memory, ASD social processing overhead. I know what makes it worse: surprise, time pressure, unfamiliar speakers, topics I didn’t prep for.

And I know what makes it better: pre-loading. Scripts turn generation into retrieval. Voice profiles turn surprise into recognition. Phrase banks give me muscle memory for the moments that used to freeze me. Recovery phrases remove the shame tax from asking for help.

It’s not elegant. It’s not transferable. It’s not inspiring. It’s just a system that a specific brain needs to function in a specific environment, built one frustrating meeting at a time, maintained because the alternative is silence.

And silence, for an engineer who has things to say, is more expensive than any workaround.