Bilingual tutors switch languages on purpose. They drop into the learner's home language to introduce a new word, check understanding, or offer encouragement. Recent work showed that large language models can be prompted to do this well when the prompt names the teaching move. That work was tested only on standard Chinese and Korean scripts. Real learners in many communities switch between English and a regional, often unwritten variety: Romanized Hindi, Zurich German, Egyptian Arabic. No one has tutoring dialogues in these varieties, and collecting them for every dialect is not realistic. We propose to treat how to teach and how to sound like this community as two separate, swappable model components. The teaching component is learned once from the tutoring data that exists. Each dialect component is learned cheaply from ordinary social-media text in that variety. The two are then combined by adding their weight changes together.
The idea borrows its structure from modular curriculum design, where a stable teaching core is kept separate from swappable specialist units. It also answers a practical complaint. Teachers who build classroom chatbots report that they cannot write realistic student vernacular (A Piece of Theatre). If dialect lives in its own module, a teacher picks the pedagogy and a community picks the variety, and neither has to author the other. The open question, which this note sets out to test, is whether teaching behavior and dialect really separate inside a network. They might instead interfere with each other when combined.
Core Claim
Our main hypothesis is that pedagogical code-switching skill can be composed with a dialect, zero-shot. Here is the concrete version. Take a base multilingual model with weights $\theta_0$. Build a pedagogy update $\tau_p$, the weight difference after fine-tuning on labeled tutoring dialogues. Build a variety update $\tau_v$, the weight difference after continued pretraining on unlabeled text in the target variety. Combine them as
$$\theta = \theta_0 + \lambda_p \tau_p + \lambda_v \tau_v,$$
where $\lambda_p$ and $\lambda_v$ are scalar weights. The claim is that this combined model produces tutoring turns with two properties at once. They carry the intended teaching move, such as clarifying, correcting, or checking understanding. They also sound like the target dialect. And they do this for a variety for which no tutoring data was ever seen.
Two papers make this plausible without establishing it. Adapting Multilingual Models to Code-Mixed Tasks via Model Merging merges a code-mixed continued-pretraining checkpoint back into its parent using task arithmetic or TIES merging, a variant that resolves sign conflicts between updates. It reports gains over full fine-tuning on Hinglish, Spanglish, Tamil-English, and Malayalam-English. But it tests only sentence classification, and it merges one skill into a base model rather than composing two different kinds of skill. Modular Adaptation of Multilingual Encoders to Written Swiss German Dialect shows that small dialect adapters, extra layers trained while the base model stays frozen, recover most of full retraining while preserving the base. That work again covers encoders and classification or retrieval only.
Optimizing Code-Switching in Conversational Tutoring Systems supplies the pedagogy side. It provides six code-switching teaching dimensions and roughly 9,000 Chinese-English and Korean-English tutoring utterances. Its own limits motivate us: it used prompting of closed models, standard scripts only, and it reports uneven quality across language pairs. What would be new here is a test of whether a behavioral skill (teaching moves) and a linguistic skill (dialect) are additive in weight space for generation. That test also yields a practical recipe for dialect tutoring without dialect tutoring data.
Research Program
We would build three kinds of module on one open multilingual decoder in the 1B–8B range. The small end matters because Kodali et al. found that merged 1B models beat prompted Llama-3.3-70B on code-mixed classification.
The first kind is the pedagogy module. We train it on the Chinese-English half of the tutoring corpus, with each tutor turn tagged by its teaching dimension.
The second kind is a set of variety modules. Each comes from continued pretraining on unlabeled text in one variety:
- Romanized Hindi-English: the SentiMix tweets and code-mixed social text of the kind Kodali et al. use.
- Swiss German: SwissCrawl and Swiss German tweets.
- Egyptian Arabic: dialectal tweets drawn from the CodSw/DiaGloss collection, plus ARZTB text.
- Korean: general Korean and Korean-English conversational text that contains no tutoring dialogue. This module exists to provide a controlled check.
The third kind is the merged models, built with task arithmetic and with TIES. The file notes that merge weights are sensitive across language pairs. To avoid quietly tuning to each test set, we fix $\lambda_p$ and $\lambda_v$ on one development pair, Korean-English, and carry them unchanged to the three new varieties. We also report the full sensitivity curves.
The analysis has two parts. The first is the controlled check on Korean-English. Gold tutoring dialogues exist for this pair, so composition can be compared directly against an oracle trained on that data. The second is open-world transfer to Hinglish, Swiss German, and Egyptian Arabic.
For the open-world varieties we would commission small test sets: about 50 tutoring scenarios per variety, built on the cartoon-description tasks from the tutoring corpus. Bilingual teachers from each community would write reference turns and later rate system output. This is in the spirit of the co-design studies by Xie et al. and Ali et al., which found that teachers adopt plug-in components that fit their existing practice.
We also measure interference directly. We check whether adding $\tau_v$ lowers the rate of correct teaching moves, and whether adding $\tau_p$ pulls output back toward standard orthography.
Baselines
The naive reference point is the base model given the pedagogical instructions from the tutoring paper and told to respond in the target variety. It has no modules. It shows what instruction-following alone delivers at this model size.
The strongest existing method is the approach of Optimizing Code-Switching in Conversational Tutoring Systems: a frontier model given structured pedagogical instructions. We would run it with an open model in the 70B class, plus one commercial model where licensing allows. It gets the same six-dimension instructions and the same scenarios. It also gets up to five teacher-written in-dialect example turns, the same examples available to our development process. That paper reports no single scalar score; the file states only "significant improvements… across six dimensions." So there is no reported result found on Lacuna for pedagogical code-switching quality to beat numerically, and we establish the number ourselves under identical judging.
The closest reported number for the merging ingredient is classification-only. Kodali et al. report a "2–5 point F1 improvement over standard full fine-tuning" and 0.65–0.68 F1 for cross-lingual transfer from Hindi-English to Tamil-English, against 0.61–0.63 for baselines. We would reproduce the Hinglish classification setting as a sanity check that our variety modules are working before using them for generation.
The key ablation is a single joint module trained on the union of the pedagogy data and the variety text. It gets the same total tokens, the same compute, and the same hyperparameter search budget as the two modules combined. If the joint module matches composition, then separation buys only convenience, not quality.
The upper bound on Korean-English is a pedagogy module trained directly on gold Korean-English dialogues. Composition counts as winning if it does three things:
- It matches the strongest baseline on teaching-move accuracy, within the confidence interval.
- It clearly beats that baseline on dialect authenticity.
- It closes at least half the gap between the naive reference and the Korean-English oracle.
Why not just…?
Why not just prompt a frontier model in the dialect? This is the real threat. Kodali et al.'s evidence of a prompting ceiling is for classification, not generation. A 70B model may well choose correct teaching moves. Our bet is narrower: it will produce standardized or stereotyped vernacular for low-resource varieties such as Swiss German and Romanized Hindi, where spelling is not standardized. The tutoring paper's report of uneven quality across language pairs hints at this. The head-to-head comparison settles it, scored separately on pedagogy and on authenticity. If the frontier model wins on both, we report that, and the contribution shrinks to a cheaper local alternative.
Why not just generate synthetic dialect tutoring data and fine-tune on it? We would run this as an extra baseline: a frontier model writes in-dialect dialogues, and our base model is fine-tuned on them. The risk is that the synthetic data inherits the frontier model's dialect errors, so the student can be no more authentic than the teacher. The authenticity scores reveal whether this happens.
Why not just normalize the learner's input to the standard language? Normalization helps the model read learners. It does nothing for producing in-dialect scaffolding, which is the thing being taught. Dialect clitics, such as the Palestinian negation circumclitics described by Habash, also lack one-to-one standard equivalents. We still include normalization of learner turns as an optional front end, to check whether it helps the system understand learners.
Why not just train one model on everything? The joint-module ablation above tests exactly this.
Proposed Experiments
We score each tutor turn on two axes.
The first axis is pedagogy. We use a classifier for the six teaching dimensions, trained on the tutoring corpus, plus teacher ratings of whether each turn performs its intended move.
The second axis is variety authenticity, measured three ways:
- Dialect-ID judges. Character n-gram Naive Bayes judges follow Eltanbouly et al., and for Swiss German we use a German Dialect ID classifier trained on ArchiMob. Dialect classifiers are known to latch onto place names and other topical cues, and these judges are no exception. We therefore hold scenario content fixed across systems, so topic cannot explain score differences.
- Code-mixing rate. This counts how much of each turn is in each language.
- Native-speaker ratings.
We also keep the classification check to make sure merging has not erased the base model's monolingual knowledge.
Three results would be decisive.
- On Korean-English, composition should recover most of the oracle's teaching-move accuracy with no Korean tutoring data.
- On the three unseen varieties, composition should beat the joint-module ablation on at least one axis without losing on the other, with merge weights fixed in advance. This is the check that separation is real.
- The interference curves should show the two modules are nearly additive. Sweeping $\lambda_v$ should raise authenticity while teaching-move accuracy stays flat.
If teaching-move accuracy falls steadily as $\lambda_v$ grows, pedagogy and dialect are entangled, and the modular premise fails for generation. That would be a useful negative result for anyone building swappable tutoring components.
References
- A Piece of Theatre: Investigating How Teachers Design LLM Chatbots to Assist Adolescent Cyberbullying Education
- Adapting Multilingual Models to Code-Mixed Tasks via Model Merging
- Modular Adaptation of Multilingual Encoders to Written Swiss German Dialect
- Optimizing Code-Switching in Conversational Tutoring Systems: A Pedagogical Framework and Evaluation
- Co-designing AI Education Curriculum with Cross-Disciplinary High School Teachers
- A Picture Is Worth a Thousand Words: Co-designing Text-to-Image Generation Learning Materials for K-12 with Educators
- Building a Corpus for Palestinian Arabic: a Preliminary Study
- Simple But Not Naïve: Fine-Grained Arabic Dialect Identification Using Only N-Grams