acceptodds
Under review as a conference paper at ICLR 2027

Context into Weights: Self-Distillation for Teaching a Small Model a Programming Language It Cannot Write

Abstract

Small language models can transfer algorithmic knowledge across programming languages, yet may fail to express that knowledge in languages whose syntax and libraries are poorly represented in their pretraining. The standard post-training recipe, supervised fine-tuning (SFT) followed by reinforcement learning with group relative policy optimisation (GRPO), breaks at both stages here: there is no high quality corpus to fine-tune on, and when no sampled program passes its tests, GRPO has no learning signal. Yet the missing knowledge is small and usable in context: with a short syntax sheet in its prompt, base Qwen3-8B solves 28 of 30 elementary Ballerina programming language problems, and none without it. We therefore replace both stages with self-distillation, in which the model with the language documentation in its context teaches the same model without it. Self-distilled supervised fine-tuning (SD-SFT) fine-tunes the model on its own documentation-conditioned programs that pass the tests. Self-distillation policy optimisation (\sdpo) then trains every token of the model's own attempts toward a teacher that also sees the documentation and the compiler's feedback. On Ballerina, where Gemma 4 E4B scores 0% pass@1, \sdsft reaches 55.4% and \sdpo 62.7%. The same incremental ordering holds across other models and languages. Because the recipe needs no corpus in the target language, only a compiler, tests and the syntax sheet, it offers a route to adapting small models to many languages that pretraining leaves out. We release all the language agnostic training data, implementation and the model weights.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
Programming Languages, Natural Language Processing

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_Vx5nOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes a training recipe for teaching small language models to write code in low-resource programming languages, where “low-resource” means that no gold-standard programs in the target language are available for training. The recipe relies on the model’s ability to transfer coding skills learned on high-resource languages to an unfamiliar language once it is shown that language’s syntactic rules. It replaces the usual SFT + RL pipeline with two self-distillation stages:

  • Self-distillation SFT (SD-SFT). A teacher, which is the same model conditioned on a syntax sheet for the target language, generates programs. Programs that pass verification are used to fine-tune a student that does not see the sheet. This moves the language knowledge from context into the weights.
  • SDPO. In the RL stage, the teacher’s context contains the syntax sheet, environment feedback, and a correct program for the problem. The teacher scores the student’s rollouts and provides dense, token-level rewards.

SD-SFT alone raises Gemma 4’s pass@1 on Ballerina by 55.4 points, surpassing frontier models; the full pipeline reaches gains of up to 62.7 points. The recipe is evaluated on Gemma 4 and Qwen 3 across Ballerina, OCaml, and Fortran.

Critical strengths
  1. Realistic and practically relevant problem setting. Assuming poor off-the-shelf performance and no gold programs in the target language reflects the real-world situation for many niche or proprietary, or newly released languages. The setting extends LLM code generation to languages that standard pipelines cannot reach.

  2. Large empirical gains. The recipe improves pass@1 by up to 62.7 points on Ballerina and outperforms frontier models with a small model. This is a notable demonstration that knowledge supplied in context can be distilled into weights.

  3. Gains also hold where the base model's performance is non-trivial. On OCaml, where the base model already has non-zero zero-shot performance, the training framework still yields clear improvements. So it is also useful for languages the model knows something about.

  4. Selective distillation is well motivated. The paper distills only what is needed: the problem-solving constructs of the target language, mined from a program in corresponding reference language. The choice is justified both conceptually and by ablation, with its limitations discussed.

Critical weaknesses

W1. No comparison against an oracle with gold programs. It is unclear whether this recipe should replace collecting ground-truth programs and running standard SFT + RL, or whether it is mainly a fallback when such data cannot be obtained. The authors should report Gemma 4 / Qwen 3 performance when gold programs in the target language are available and standard SFT followed by SDPO is used. This gives an upper bound and shows how much of the gap self-distillation closes. A data-efficiency curve would be even more useful: how many gold programs are needed to match the self-distilled model? That would tell practitioners when collecting data is worth it.

W2. Effect on other languages (catastrophic forgetting). The paper does not report how performance on high-resource languages such as Python or JavaScript changes after the model is optimized for a target language like Ballerina. For a recipe meant to add a language, preserving existing ability is an essential property. It would be interesting to train on several target languages at once, to see whether they interfere with each other.

W3. Missing ablation on the teacher’s SDPO context. It is unclear why the teacher needs a passing program in its context during SDPO. Can the teacher score student rollouts adequately with only the syntax sheet and environment feedback? Please report results with zi=(sheet(x),fi)z_i = (\text{sheet}(x), f_i), i.e., without a correct solution. This matters for two reasons. First, it shows how much of the dense reward comes from comparing against a known solution rather than from the teacher’s own understanding of the language. Second, as W4 explains, it affects training cost.

W4. Cost and coverage of teacher resampling. This follows from W3. When the student fails to produce a correct solution, the teacher must be sampled again to obtain one, which adds training cost. Please report: (a) the fraction of training problems that required teacher resampling; (b) the fraction of problems discarded because the teacher also failed to find a correct solution. Can you also describe how the discarded set is distributed by difficulty. If hard problems are systematically filtered out, the learned policy may be biased toward easy constructs.

W5. Missing ablation on the discard threshold mm. There is no experiment on how the threshold mm for discarding problems affects final performance. This ablation would answer whether hard problems, where the teacher found few or no correct solutions, still provide useful learning signal during RL. One would expect them to: the dense reward depends on the teacher’s ability to localize errors in incorrect student programs, not on its ability to generate correct programs itself, and verification is often easier than generation. This intuition goes back to the complexity-theoretic P vs. NP distinction (Cook, 1971).

W6. How “unseen” are the target languages? Can you further quantify base-model familiarity using for e.g. perplexity on target-language code?

Questions for authors

See Weaknesses section.

6 comments
AuthorsOpenReview ↗

(1/2) Authors response to reviewer Vx5n

We thank the reviewer for the positive feedback and the questions. We address all concerns raised below.

 

W1. A gold-program oracle. No gold corpus exists for these problems, but that is not the main obstacle. Even with a gold program for every problem, SFT on gold programs is not an option for these models, because it either destroys the reasoning or breaks the policy. Both base models reason before they answer, so a training example is reasoning followed by a program, and a gold program has no reasoning. That leaves two choices, and both fail. This is not a question of data efficiency.

  • SFT on gold programs alone destroys the reasoning. The model is trained to emit a program directly. Reasoning is about 85% of each answer the trained model writes (median over 477 benchmark samples, by characters), and it holds 90% of the highest-signal tokens in stage two.
  • Gold programs with another model's reasoning break the policy. That reasoning is not how this model thinks. Fitting it pulls the model off its own distribution and costs general ability, which training on the model's own outputs reduces (Yang et al., 2024; Shenfeld et al., 2026).

Self-distillation avoids both: every example is the model's own reasoning and its own program, kept only if the program passes, and the new knowledge enters through the sheet.

RL, the other standard route, transfers no new knowledge: a reward can only reinforce programs the model already writes, and the base model writes no passing Ballerina program (0.0).

The remaining option is GRPO after stage one. We report the results below (Table 3), which show that SDPO works better in that setting.

ArmBallerina (pass@1)OCaml (pass@1)
SD-SFT55.450.1
+ GRPO-only54.851.1
+ SDPO60.856.8

We will include this explanation in the discussion.

 

W2. Forgetting. We ran a Python control on HumanEval (164 problems, three samples per problem) using models fine-tuned on Ballerina. The results are below; the difference is within sampling noise.

Modelpass@1pass@3
Gemma 4 E4B-it94.997.0
after Ballerina SD-SFT94.396.3
Qwen3-8B92.795.7
after Ballerina SD-SFT91.395.7

 

W3. Why does the teacher see a passing program? The "passing program" is not a gold or reference solution. It is a program the model wrote in the same round (a sibling rollout, or one of the teacher's own gated samples) that compiled and passed the hidden input/output tests, which we call agnostic tests. Correctness is decided only by execution (§2.1).

To separate the two sources of signal, we re-scored the same failed rollouts with and without the passing program in the teacher's context:

Teacher seesDivergence per tokenSuccessful completions
Without passing program0.03036%
With passing program0.076100%

With the passing program, the learning signal is stronger (divergence is higher), and the share of successful completions rises from 36% to 100%.

 

W4. Cost and coverage. The statistics below come from the SDPO runs and show how the method handles problems where the student cannot pass a single rollout.

StatisticShare
No passing student rollout, so we sampled the teacher with the hint25% (61 of 240)
... of those, the teacher passes the gate28% (17 of 61)
Dropped (failed by both student and teacher), of all problems18% (44 of 240)
Additional share of generated tokens / training time used by the teacher13% / 22%

For 75% of problems, the teacher adds no cost.

Mean (median)Kept (196)Dropped (44)p
Syntactic load (constructs needed)5.1 (5)5.9 (6)0.02
Python reference length (lines)15.2 (13)18.0 (16.5)0.13
Contest rating1103 (1000)1150 (1150)0.74

Only syntactic load differs significantly: 27% of problems needing more than six constructs are dropped, against 15% of those needing four or fewer. Length and rating do not differ. No construct is lost: every construct a dropped problem needs also appears in kept problems.

AuthorsOpenReview ↗

(2/2) Authors response to reviewer Vx5n

W5. SDPO selection threshold. This is a design principle, not a tuned hyperparameter: we train on a problem only if at least one candidate program passes its tests. We did not ablate this condition because our early experiments showed that training on data not grounded in real-world signals often leads to performance collapse at unexpected points. For example, in initial experiments we also rewarded compilation. When no rollout passed the tests, we used a program that merely compiled as the training target, which made the target suboptimal. The model then learned to aim for compilation alone, producing trivial "hello world" programs that compiled but solved nothing.

Although verification is easier than generation, our method relies on the compiler and tests to verify programs and ground training in a concrete signal. Without a passing program, the teacher has no verified solution on which to ground its feedback.

 

W6. Perplexity across foreign languages. We selected ~200 human-written programs from each language's documentation and measured perplexity by replaying each program through the model. The results are below.

ModelLanguageBits per byteBytes per tokenPerplexity
Gemma 4 E4BBallerina0.9133.6610.1
Gemma 4 E4BPython0.9213.006.8
Qwen3-8BBallerina0.5754.115.2
Qwen3-8BPython0.4893.363.1

 

We hope we have answered all of your concerns and provided sufficient clarity. If you need further information or clarification, please let us know. Thank you again for the insights.

I thank the authors for addressing my concerns.

  • Regarding W1. I understand that training only on gold programs without reasoning traces could break the model's own ability to reason. What I wanted to understand is whether, if an LLM encounters an unknown or low-resource language on which it performs poorly, the effort should be directed towards collecting ground-truth data for it or using an approach like SD-SFT?

  • Regarding W2. Resolved

  • Regarding W3. Resolved

  • Regarding W4. It seems nearly 20% of problems are being dropped. Please add the results of this to the main body of the paper, either as a limitation or as future work that you can address to further improve performance.

Reviewer_b9QvOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

Authors present a method to train a model on an effectively no-resource language by relying on previously published algorithms (SD-SFT and SDPO), manually preparing a training dataset, and following a curriculum approach. Such training is particularly important for domain-specific programming languages, which are vital but constitute a long tail in the distribution of coding data.

Critical strengths
  1. Some gains from the method are very significant compared to prior work (Ballerina, OCaml).
  2. It is interesting how significant the gains from the initial SD-SFT training are. The model learns to produce compiling code far more often, and the resulting knowledge transfers to tasks unseen in training.
Critical weaknesses
  1. The experiments are limited. It is unclear how well the gains scale with model size, and if there is no negative transfer across programming languages.
  2. Parts of the training method are syntax-based. It is not clear how the method scales to learning libraries, agentic behavior, language-specific tooling.
Questions for authors
  • Can the authors train models in multiple sizes from the same family to clarify how the gains scale with model size? For presentation, it would help to e.g. show a table where trained models of various sizes from multiple familes are compared on the same benchmark, and to include untrained models in the same table.
  • Can the authors show results where the models are trained on multiple programming languages, or otherwise evalute that there is no negative cross-language transfer?
  • Please describe how the Primer dataset was authored. It is unclear what the problems in the dataset are. Sec 2.4 says the dataset tasks focus on one focal construct each, suggesting the task are language-specific, but Sec. 2.7.1 says that there are no reference solutions in "any language",
  • Please clarify what was the stage 1 train dataset for OCaml and Fortran.
  • How much of the gains from stage 1 training can be attributed to the Primer dataset, as opposed to the algorithm?
  • In Table 3, please clarify what is presented in the "full reference" and "retrieval" rows.
  • Please note that ICLR explicitly allows appendices in submissions.
2 comments
AuthorsOpenReview ↗

Authors response to reviewer b9Qv

We thank the reviewer for the precise questions, which help us improve the submission.

 

W1 / Q1. Model size. We ran the following experiment with three sizes of Gemma 4: E2B, E4B (the paper's model), and 26B-A4B (26B parameters, about 4B active). The results are below.

Gemma 4Untrained model (pass@1)Harvest yieldOur SD-SFT (pass@1)
E2B0.00.1%0.0
E4B0.047%55.4
26B-A4B0.476.6%64.4

Harvest yield and stage-one performance increase with model size. This is likely because the ability to use in-context information grows with scale (Wei et al., 2023). Size therefore sets the harvest.

 

W1 / Q2. Results of a checkpoint trained on multiple programming languages. We trained a single model on Ballerina and OCaml together (interleaved). The comparison is controlled: each language keeps exactly the data of its single-language run, shuffled, seen the same number of times, in an adapter of the same size. The results are below and match the two models trained alone (pass@1; neither difference is significant).

Scored onTrained aloneTrained togetherDifference (95% CI)
Ballerina55.358.5+3.1 [−1.3, +7.5]
OCaml50.648.5−2.1 [−6.5, +2.3]

 

W2. Support for libraries, agents, and tooling. We agree these are valuable directions. However, they are outside the scope of this paper, which asks whether a model can learn to write a language it cannot write at all. Our Limitations section (§6) states this scope: training covers general-purpose constructs, not domain-specific constructs or external libraries, and evaluation covers single-file, function-level problems, not repository-level tasks. We leave agentic and tool-use settings to future work.

 

Q3. How PRIMER was built. PRIMER is a curriculum designed around two objectives: (1) each problem needs one focal construct and minimal other syntax; (2) within that limit, it stays as close as possible to competitive-programming problems (Codeforces) in form and difficulty.

A focal construct is a language-independent concept (a loop, a map, string splitting), not target-language code; the per-language sheet supplies its syntax.

For each focal construct, we generate multiple problems using an LLM (Claude Opus 4.8). For each problem, the LLM also writes a Python reference, which we use only to compute expected test outputs and to identify the other minor constructs the problem uses (for hints). All problems follow the Codeforces format, which provides language-agnostic test cases. PRIMER ships no solution in any language, Python included. Training programs are the base model's own, kept only if they pass.

 

Q4. Stage-one data for OCaml and Fortran. For stage one in all three languages, we used PRIMER problems and tests, a per-language inventory, and programs sampled from the base model with the sheet (n=5), kept if the compiler and the language-agnostic tests accept them.

 

Q5. PRIMER against the algorithm. Table 3 isolates the curriculum's contribution: "SD-SFT without curriculum" uses the same algorithm but replaces PRIMER with CONTEST-MIXED (Table 2). This change lowers the Ballerina score from 55.4 to 8.8 and the OCaml score from 51.9 to 42.4.

SD-SFT (Table 3)BallerinaOCaml
CONTEST-MIXED8.842.4
PRIMER55.451.9

 

Q6. Clarification of "full reference" and "retrieval". "Full reference": the official documentation for general-purpose code, placed in the prompt. For Ballerina, this is Ballerina by Example's language concepts plus the core library API. For OCaml, it is the manual's core-language and module chapters plus the standard-library interfaces.

"Retrieval": we split the same official documentation into chunks of at most 2,000 characters. For each problem, we retrieve the 8 chunks closest to the query using bge-small-en-v1.5, a widely used public embedding model, and the model sees only those 8.

 

Thank you for the note on the appendices; the revised PDF includes them. We hope this response addresses your concerns.

Thank you for your response. My main concerns were addressed and I will raise the raiting.

Reviewer_FowyOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper looks at teaching small models a programming language they can't write because it was rare in the training data. The authors observe that the model can write the language when a short per-problem syntax sheet is in its prompt, so they train the model without the sheet to imitate itself with the sheet. This happens in two stages: SD-SFT, which fine-tunes on the model's own passing programs, and SDPO, which gives token-level guidance from a copy of the model that sees the sheet and compiler feedback. They test mainly on Ballerina, which the base models can't write at all, and on OCaml, using two small models (Gemma 4 E4B and Qwen3-8B). Stage 1 gives a large gain on Ballerina.

Critical strengths

-On Ballerina, Gemma goes from 0 to 55.4 after Stage 1 and 62.7 after Stage 2 (Table 3), with no Ballerina training data. -The paper shows why it works. Table 5 sorts every failed program by its compiler error. The gains come mostly from fewer made-up function names and less grammar borrowed from other languages.

Critical weaknesses
  • Ballerina is the only language at zero for both base models (line 157), but the abstract says the method "offers a route to adapting small models to many languages that pretraining leaves out."
  • A "GRPO only" comparison is described (line 250), but no result for it appears in the submitted PDF.
  • A Python check that "learning a new language costs no general coding skill" (line 289) has no numbers in the submitted version.
  • The appendix is missing, but the main text refers to it throughout, so there are several broken references as "Appendix ??".
Questions for authors

Please include the missing appendix, and report the "GRPO only" arm (line 250), results over several training seeds on Ballerina, and the Python control (line 289). Without seeds and the GRPO-only result, it's hard to judge SDPO truly beats GRPO.

4 comments
AuthorsOpenReview ↗

Authors response to reviewer Fowy

We thank the reviewer for their thoughtful feedback, and our responses are listed below. We agree with all four points and have fixed each one.

 

W1. Fixing the overclaim in the Abstract. We agree that the abstract saying "offers a route to adapting small models to many languages that pretraining leaves out" claims more than we measure. We will change the abstract to say "it offers a route to adapting small models to low-resource languages."

We have only referred to "no-resource" languages in line 152 of the paper, but there is no clear measurable definition. If we use a practical definition such as less than 10% on a benchmark, and consider the Agnostics paper results (Table 1a), no languages are classified as no-resource on HumanEval, while OCaml and Fortran are classified as such on LCB. So we will remove the reference to no-resource from the claim and discuss it in the discussion section. Even with low-resource languages, our method helps when there is not enough training data.

We do acknowledge that adding a result from a language similar to Ballerina with "no-resource" status would strengthen our paper. If the timing works we will do our best to add another language (e.g., Gleam or MoonBit).

 

W2. The GRPO-only row is missing. We ran the GRPO-only arm using the same dataset as SDPO as an ablation of our method; the results are below. We will add them as an additional row in the main results table.

ArmBallerina (pass@1)Comp.OCaml (pass@1)Comp.
SD-SFT55.458.450.154.3
+ GRPO-only54.858.451.154.5
+ routed58.361.655.159.3
+ SDPO60.864.456.861.4

 

W3. The Python control ablation. We ran the Python control on HumanEval (164 problems, three samples per problem) using models fine-tuned on Ballerina. The results are below; the difference is within sampling noise.

Modelpass@1pass@3
Gemma 4 E4B-it94.997.0
after Ballerina SD-SFT94.396.3
Qwen3-8B92.795.7
after Ballerina SD-SFT91.395.7

 

W4. The appendix is missing. This was our error. The appendix was submitted as supplementary material, but we exported the main PDF with it removed, which broke the cross-references. The revised PDF contains the full appendix, and every reference resolves.

 

Q1. Seeds. We agree that a single seed cannot settle SDPO against GRPO. We trained two more seeds on Ballerina and OCaml. Each run changes the seed, data order, rollout sampling, and adapter initialisation, and keeps the prompts and evaluation fixed. All runs are scored with ten samples (n=10) per problem on the MultiPL-E benchmark.

SeedBallerinaOCaml
159.754.1
259.956.1
362.756.8
mean (sd)60.8 (1.7)55.4 (1.9)

The improvement holds across all three seeds for both Ballerina and OCaml.

 

We thank the reviewer again for their valuable feedback, which has helped us improve the paper further. If any of these answers leaves a concern open, we would be glad to run further checks during the discussion.

AuthorsOpenReview ↗

Follow-up on Reviewer Fowy

Dear Reviewer Fowy,

Thank you again for your feedback and time/effort reviewing our paper. Since the rebuttal period is ending soon, please let us know if our responses have addressed your concerns. We are happy to engage in further discussion to provide more clarifications if needed.

Thank you!

Thanks for addressing the comments. It would have been useful to provide seed variance for 'GRPO-only', not just SDPO. I'm staying with the original score.

AuthorsOpenReview ↗

Authors follow-up on Reviewer Fowy

We thank the reviewer for the follow-up. We trained GRPO-only on Ballerina with the same three training seeds as SDPO. For each seed, the runs start from the same SD-SFT checkpoint and train on the same problems in the same order.

SeedGRPO-only (pass@1)
153.2
253.2
353.7
mean (sd)53.4 (0.2)

Scores are pass@1 on Ballerina at the final checkpoint, with three samples per problem.

GRPO-only gives no gain over SD-SFT on any seed (−2.0 points over the three seeds, 95% interval −4.6 to +0.5), and its scores differ by at most 0.5 points across seeds. With the same seeds and the same scoring, SDPO is 6.8 points above GRPO-only (95% interval +3.6 to +10.1, p < 0.001). We will add the GRPO-only seeds to the paper.

We thank the reviewer again for the valuable feedback and for the time devoted to our paper.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Summary of Rebuttal

We thank all three reviewers for their constructive critiques and careful reading of our work. We are grateful that the reviews identified consistent strengths in the submission, and the comments have been valuable in improving the manuscript.

Strengths: All three reviewers highlighted the large empirical gains: a small model goes from zero to 55.4 pass@1 on Ballerina with no training data in that language, with gains that are significant against prior work and that also hold on OCaml, a language the base model partly knows.

The reviews also recognized the realistic and practically relevant problem setting (poor off-the-shelf performance and no gold programs), the analysis of why the method works through the failure taxonomy, and the well-motivated selective distillation, which transfers only the constructs a problem needs.

In response to the concerns raised, we have made the following additions and changes to the manuscript.

  1. [Added more data points to extend the baseline] The GRPO-only arm adds nothing over stage one (54.8 against 55.4 on Ballerina), while SDPO reaches 60.8 (Table 3). We also ran SDPO with additional training seeds (Section 3 and Appendix), addressing Fowy (W2), Fowy (Q1).
  2. [Added new experiment] A Python control shows no measurable loss of general coding ability (94.9 → 94.3) (Appendix: Python control), addressing Fowy (W3), Vx5n (W2).
  3. [Added new ablation] Across three sizes of Gemma 4, yield and stage-one performance grow with model size (55.4 → 64.4 from E4B to 26B-A4B) (Appendix: Model size), addressing b9Qv (W1, Q1).
  4. [Added new experiment] A single model trained on Ballerina and OCaml together performs on par with the two models trained alone (Appendix: Multi-language training), addressing b9Qv (Q2).
  5. [Added new experiment] Keeping the harder problems gives no measurable gain in SDPO (Appendix), addressing Vx5n (W4, W5).
  6. [Extended analysis] To examine the mechanism, we measured:
    • What the passing program adds to the teacher's signal (Section 3.2), addressing Vx5n (W3).
    • How often the teacher is sampled (Section 3.2), addressing Vx5n (W4).
    • How many problems the gate drops (Section 3.2 and Limitations), addressing Vx5n (W4).
    • The perplexity of the base models on Ballerina (Appendix), addressing Vx5n (W6).
  7. [Further clarifications]
    • The scope: general-purpose constructs and single-file problems, not external libraries (Section 6), addressing b9Qv (W2).
    • The curriculum's contribution, apart from the algorithm: 8.8 → 55.4 on Ballerina (Table 3), addressing b9Qv (Q5).
    • What "full reference" and "retrieval" mean (Table 3 caption and Appendix), addressing b9Qv (Q6).
    • When to collect ground-truth data and when to use SD-SFT (Section 4), addressing Vx5n (W1).
    • What the teacher costs: 13% of the generated tokens (Section 3.2 and Appendix), addressing Vx5n (W4).
    • How PRIMER was built, the stage-one data for each language, and the reference rows of Table 3, addressing b9Qv (Q3, Q4).
  8. [Restored appendix] We restored the appendix that our export had dropped from the PDF, addressing Fowy (W4), b9Qv (Q7).
  9. [Narrowed claim] We narrowed the abstract's claim, addressing Fowy (W1).

We have addressed the key points raised through these revisions by adding new experiments, ablations, analysis, and clarifications. We believe the revised paper presents a well-supported account of how to teach a niche programming language to a small model.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.