Pith. sign in

REVIEW 5 major objections 5 minor 35 references

Offline compiler feedback plus difficulty-curated RL lets an 8B model beat prior SOTA on Julia and bootstrap Ballerina.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.5

2026-07-10 19:47 UTC pith:3VK3ZBC5

load-bearing objection Solid engineering recipe for LRPL code gen with real Julia gains and a useful Ballerina cold-start demo; the additive three-phase story is oversold where GRPO hurts easy MultiPL-E competence. the 5 major comments →

arxiv 2607.07748 v1 pith:3VK3ZBC5 submitted 2026-07-08 cs.LG

Selective Left-Shift: Turning Test-Time Compute and Difficulty-based Curation into Training Data for Low-Resource Code Generation

Didula Samaraweera , Anjana Supun , Srinath Perera This is my paper
classification cs.LG
keywords code generationlow-resource programming languagessmall language modelsreinforcement learninginference-time scalingsupervised fine-tuningcompiler feedbackdifficulty curation
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Small language models struggle on low-resource programming languages because there is almost no training data, live multi-round refinement is too slow for real use, and pure reinforcement learning rarely gets a positive signal when the model still makes syntax mistakes. This paper claims the three problems can be solved together by moving expensive iterative compiler-and-test refinement offline: the model generates candidates, receives real error and failed-test feedback, and only verified solutions are kept as training data. Those solutions are used for a short supervised fine-tuning stage that installs syntactic priors. A later reinforcement-learning stage then optimizes functional correctness with language-agnostic input-output tests, but only on problems whose difficulty sits near the model’s current frontier, so that some completions pass and others fail and the relative advantage is informative. On an 8B base model the full pipeline raises Julia pass@1 above previous state-of-the-art results while using roughly one-third the data and one-sixth the reported cost, and it produces usable Ballerina code from a near-zero starting point.

Core claim

The authors establish that left-shifting inference-time iterative refinement into an offline, compiler-and-test verified data synthesis step, followed by syntax-aware supervised fine-tuning and then Group Relative Policy Optimization on a difficulty-curated slice of language-agnostic IO problems, resolves the data-scarcity / inference-cost / sparse-reward trilemma for low-resource code generation. On Qwen3-8B the pipeline improves Julia MultiPL-E pass@1 by up to 7.6 points and Agnostics LiveCodeBench by 14.2 points over prior SOTA, with far less data and cost, and generalizes to Ballerina (near-zero pretraining) at 49.7 % MultiPL-E pass@1.

What carries the argument

Selective Left-Shift pipeline: offline iterative compiler/test feedback that retains only fully verified solutions, syntax-aware SFT that embeds language priors, and GRPO with partial IO rewards, zero-advantage masking, and ELO-window difficulty curation that keeps advantages non-degenerate.

Load-bearing premise

That an ELO-selected difficulty band plus zero-advantage masking will keep RL advantages informative and stable without eroding the simpler competencies already gained by supervised fine-tuning.

What would settle it

Run the identical pipeline on another extreme low-resource language and check whether the final GRPO stage simultaneously raises both the easy MultiPL-E suite and the harder LiveCodeBench suite; a clear drop on the easy suite while the hard suite rises would falsify the claim that difficulty curation preserves broad competence.

Watch this falsifier — get emailed when new claim-graph text bears on it.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

5 major / 5 minor

Summary. The paper proposes a three-phase pipeline for adapting 8B-class SLMs to low-resource programming languages (LRPLs): (1) offline iterative compiler/test-feedback synthesis that left-shifts test-time compute into verified training data; (2) syntax-aware SFT on that data; (3) GRPO with language-agnostic IO rewards, zero-advantage masking, and difficulty curation via a Codeforces-ELO frontier window (Eqs. 10–11). On Qwen3-8B the full pipeline reports Julia pass@1 of 68.6% MultiPL-E and 39.2% Ag-LCB (claimed +7.6 / +14.2 over Agnostics SOTA) at roughly 1/3 the RL data and 1/6 the cost, plus Ballerina results (49.7% MultiPL-E, 25% Ag-LCB) as a near-zero-pretraining cold-start case. Ablations compare SFT-only, no-SFT GRPO, and random vs ELO-curated GRPO sets.

Significance. If the Julia gains and cost claims hold under consistent methodology, the work is a practical contribution to LRPL code generation: it reframes expensive iterative refinement as a one-time offline investment, couples syntax SFT with execution-grounded GRPO, and ships a human-annotated Ballerina MultiPL-E extension. Strengths include explicit cost accounting, error-category analysis (Table 3), difficulty-curation ablations (Table 4, Fig. 5), and a language-agnostic IO reward design. The Ballerina cold-start experiment is especially valuable if the pipeline is shown to be robust rather than trading easy-benchmark competence for hard-benchmark gains. These elements make the paper relevant to both code-LLM and low-resource adaptation audiences.

major comments (5)
  1. Table 1 vs Table 3 inconsistency on Julia MultiPL-E: Table 1 reports Full Pipeline pass@1 = 68.6, while Table 3’s “Correct” column for Full is 63.5 (and SFT-only matches 57.9 in both). The error breakdown is used to argue that SFT kills syntax errors and GRPO then reduces wrong-output errors; a 5-point gap between the main result table and the diagnostic table undermines that narrative and must be reconciled (or both tables recomputed from the same evaluation run).
  2. Table 1 Ballerina MultiPL-E: SFT-only reaches 56.0 while Full Pipeline drops to 49.7, even as Ag-LCB rises 9.9→25.0. The abstract and contributions still headline 49.7% as the generalization result and describe phases as complementary/additive. This is load-bearing for the “resolves the trilemma / generalizes to extreme LRPLs” claim: either analyze the regression (forgetting, reward hacking, ELO window mismatch with MultiPL-E difficulty) with a controlled freeze of the SFT checkpoint, or qualify the additive-pipeline claim and report SFT-only as the MultiPL-E headline for Ballerina.
  3. §3.2 / Algorithm 1 vs §4.3 synthesis model mismatch: Phase 1 is formalized as iterative refinement with the base model M_θ, but §4.3 states candidates are generated with Claude Code or OpenAI OSS-120B “based on its difficulty,” then verified. If stronger external models produce D_L, the “left-shift of the SLM’s inference-time compute” framing and the cost comparison to Agnostics need re-statement; the paper should report which fraction of verified Julia/Ballerina SFT data came from which generator and re-run a pure-M_θ synthesis baseline if the left-shift claim is retained.
  4. §3.4.5 Eqs. (10)–(11): ELO_m is defined via a derivative condition d r_test / d elo < −θ whose estimation procedure, θ value, and validation of the problem-ELO predictor are not specified. Table 4 shows curated vs random (68.6 vs 52.2) but without multi-seed variance, sensitivity to the +400 window, or a plot of reward slope vs ELO for the SFT policy, it is unclear whether the Julia SOTA delta is robust to the free parameters of the curation rule—the same rule that coincides with the Ballerina MultiPL-E regression.
  5. Table 2 SOTA comparison: Agnostics numbers are for Qwen3-4B-MBPP (62 / 15) and Qwen3-8B-CF (61 / 25), not the same Qwen3-8B base used here. The +7.6 / +14.2 claims should be accompanied by a same-base re-evaluation or an explicit caveat that base-model and recipe differences are confounded; otherwise the efficiency claim (1/3 data, 1/6 cost) is hard to interpret as a pure pipeline win.
minor comments (5)
  1. Multiple typos of the base model name as “Qwan” (§5.1.1, §6) and “it’s” for “its” (§4.3).
  2. Figure 1 y-axis and bar labels are dense; a clearer legend mapping “Ours (SFT)” vs “Ours (Full)” to Table 1 would help.
  3. §3.4.5 notation mixes 𝑑.𝑒𝑙𝑜, 𝐷.𝑒𝑙𝑜, and 𝐸𝐿𝑂_𝑚 + 400𝐷.𝑒𝑙𝑜; standardize symbols and define the ELO predictor training data.
  4. Abstract claims “+7.6 points on MultiPL-E … compared to SOTA” while Table 2’s best Agnostics MultiPL-E is 62; state the exact baseline number used for the delta.
  5. Release note for the Ballerina MultiPL-E extension is welcome; please confirm number of problems (159) and whether tests are execution-identical to HumanEval IO.

Circularity Check

0 steps flagged

No significant circularity: empirical pipeline with external compiler/IO oracles and held-out benchmarks; difficulty curation is a design choice, not a tautology.

full rationale

The paper's three-phase pipeline (offline iterative synthesis via sandbox compiler/test feedback → SFT on verified pairs → GRPO with IO-test rewards and ELO-based curation) is an empirical engineering method evaluated on independent MultiPL-E and post-cutoff Ag-LCB pass@1. Phase-1 verification (Algorithm 1, Eq. 1) and Phase-3 rewards (Eqs. 6–7, partial test + build scores) are supplied by external execution oracles, not by redefining the reported metric. Difficulty selection (Eqs. 10–11) uses external Codeforces ELO plus a slope threshold to concentrate training signal; it does not force the held-out pass@1 numbers by construction. Zero-advantage masking (Eq. 8) discards uninformative groups but does not circularly manufacture advantages. No self-definitional loops, no fitted parameters renamed as predictions of the same quantities, no load-bearing self-citations of uniqueness theorems, and no ansatz smuggled via overlapping-author citations (Agnostics is a distinct group). The Ballerina MultiPL-E regression is a robustness observation, not circularity. The chain is self-contained against external benchmarks and oracles.

Axiom & Free-Parameter Ledger

5 free parameters · 5 axioms · 2 invented entities

The central performance claims rest on standard ML training assumptions plus several design knobs (iteration caps, reward weights, ELO window, group size, masking rule) and the domain premise that compiler+IO feedback is a sufficient oracle for “verified” LRPL code. No new physical entities; the pipeline and masking rule are methodological constructs. Free parameters are mostly training/hyperparameter choices that affect reported gains.

free parameters (5)
  • K_max (max refinement iterations in offline synthesis)
    Caps how many compiler/test feedback rounds are allowed before discarding a problem; directly controls size and difficulty of D_L.
  • alpha (build-quality weight in composite reward)
    Scales r_build vs r_test in Eq. 7; shapes whether GRPO prioritizes compilation structure over test pass rate.
  • theta and ELO_m / +400 ELO window for GRPO curation
    Eq. 10–11 define which Codeforces difficulties enter training; chosen thresholds determine the “frontier” set of ~500 problems.
  • G=8 GRPO group size; LoRA r=16, alpha=32; learning rates 1e-4 / 5e-5
    Standard but claim-affecting training knobs; not derived from theory in the paper.
  • Zero-advantage mask threshold r_max = 1.0
    Only groups with a fully correct completion contribute gradients; a hard design choice that discards most updates (Fig. 4).
axioms (5)
  • domain assumption Passing a finite IO test suite (or differential tests when available) is sufficient verification for including a synthetic solution in SFT data.
    Stated in §3.2; admits residual semantic bugs not covered by tests, which could embed faulty priors.
  • domain assumption SFT on verified LRPL solutions embeds syntactic priors that make GRPO advantages non-degenerate (syntax errors no longer dominate).
    Core hypothesis in §3.4.6 and Introduction; supported by ablations but not guaranteed for all languages.
  • domain assumption Codeforces-style ELO (and a predicted ELO for problems) ranks algorithmic difficulty in a way that transfers to the model’s learning frontier.
    §3.4.5; ELO predictor details are thin.
  • domain assumption Language-agnostic IO tests and a working compiler/runtime are available for the target LRPL.
    Required for Phase 1 sandbox and Phase 3 rewards; explicit for Ballerina bootstrap claim.
  • standard math GRPO with group-relative advantages and KL to SFT reference is a valid policy optimization setup for code.
    Adopted from DeepSeekMath GRPO and Agnostics-style environments; standard in recent code RL.
invented entities (2)
  • Selective left-shift three-phase pipeline (offline iterative synthesis + syntax SFT + difficulty-curated GRPO) no independent evidence
    purpose: Organize compute so syntax is learned offline and RL explores functional logic under constrained action space.
    Methodological construct, not a physical entity; value is empirical. Independent evidence is the reported benchmarks, not an external falsifiable object.
  • ELO_m frontier curation rule (Eq. 10–11) no independent evidence
    purpose: Select GRPO problems at the edge of model competence to maximize non-zero advantages.
    Paper-specific selection formula built on Codeforces ELO; success judged only by downstream pass@1 in this work.

pith-pipeline@v1.1.0-grok45 · 21284 in / 4123 out tokens · 48248 ms · 2026-07-10T19:47:09.080489+00:00 · methodology

0 comments
read the original abstract

Large Language Models achieve strong code generation for high resource languages like Python and Java but suffer sharp performance drops on Low-Resource Programming Languages~(LRPLs) such as Julia. Improving Small Language Models~(SLMs) for these languages faces a trilemma: Supervised Fine-Tuning~(SFT) is bottlenecked by data scarcity, inference-time scaling is too expensive for deployment, and Reinforcement Learning from scratch yields near zero advantages. We propose a three-phase pipeline that resolves this trilemma by decoupling syntax acquisition from algorithmic reasoning. First, we \emph{left-shift} inference-time compute to an offline data synthesis engine that uses iterative compiler and test feedback to generate verified training examples. Second, we fine-tune an SLM on this synthetic, verified data to embed strong syntactic priors. Third, we apply Reinforcement Learning with Verifiable Reward~(RLVR) grounded by language-agnostic Input/Output tests, where the SFT prior constrains exploration away from syntax errors. Applied to Qwen3-8B, our pipeline improves pass@1 by up to +7.6 points on MultiPL-E and +14.2 points on the Agnostics LiveCodeBench for Julia compared to SOTA results. Furthermore, the pipeline only used $\frac{1}{3}$ data and $\frac{1}{6}$ cost over the previous state-of-the-art. We further demonstrate that the pipeline generalizes to Ballerina achieving 49.7\% MultiPL-E Pass@1, a language with near-zero pretraining representation. Ablations confirm that both the SFT phase and execution-grounded rewards are necessary for stable training.

Figures

Figures reproduced from arXiv: 2607.07748 by Anjana Supun, Didula Samaraweera, Srinath Perera.

Figure 1
Figure 1. Figure 1: Comprehensive evaluation of code generation per [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: Overview of the three-phase pipeline. Phase 1 repurposes iterative refinement as an offline data curation engine: [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Worked example of iterative compiler-feedback [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Reward standard deviation across training steps [PITH_FULL_IMAGE:figures/full_fig_p009_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Comparison of GRPO reward vs. Codeforces problem ELO between our pipeline (Left) and the Agnostics pipeline [1] [PITH_FULL_IMAGE:figures/full_fig_p010_5.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

35 extracted references · 35 canonical work pages · 16 internal anchors

  1. [1]

    Aleksander Boruch-Gruszecki, Yangtian Zi, Zixuan Wu, Tejas Oberoi, Carolyn Jane Anderson, Joydeep Biswas, and Arjun Guha. 2026. Agnostics: learning to synthesize code in any programming language with a universal reinforcement learning environment. InThe Fourteenth International Conference on Learning Representations. https://openreview.net/forum?id=mjDT60Ffms

    work page 2026

  2. [2]

    Federico Cassano, John Gouwar, Francesca Lucchetti, Claire Schlesinger, Car- olyn Jane Anderson, Molly Q Feldman, Michael Greenberg, Abhinav Jangda, and Arjun Guha. 2024. Knowledge transfer from high-resource to low-resource programming languages for code LLMs.Proceedings of the ACM on Program- ming Languages (PACMPL), 8, OOPSLA

    work page 2024

  3. [3]

    Federico Cassano et al. 2023. Multipl-e: a scalable and polyglot approach to benchmarking neural code generation.IEEE Trans. Softw. Eng., 49, 7, (July 2023), 3675–3691. doi:10.1109/TSE.2023.3267446

    work page doi:10.1109/tse.2023.3267446 2023

  4. [4]

    CodeT: Code Generation with Generated Tests

    Bei Chen, Fengji Zhang, A. Nguyen, Daoguang Zan, Zeqi Lin, Jian-Guang Lou, and Weizhu Chen. 2022. Codet: code generation with generated tests.ArXiv, abs/2207.10397. https://api.semanticscholar.org/CorpusID:250920542

    work page internal anchor Pith review Pith/arXiv arXiv 2022

  5. [5]

    Hanting Chen et al. 2025. Pangu embedded: an efficient dual-system llm rea- soner with metacognition.ArXiv, abs/2505.22375. https://api.semanticscholar .org/CorpusID:278959233

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  6. [6]

    Mark Chen et al. 2021. Evaluating large language models trained on code.arXiv preprint arXiv:2107.03374

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  7. [7]

    Fan Cui et al. 2024. Origen: enhancing RTL code generation with code-to- code augmentation and self-reflection. InProceedings of the 43rd IEEE/ACM International Conference on Computer-Aided Design

    work page 2024

  8. [8]

    Anders Ericsson

    K. Anders Ericsson. 2008. Deliberate practice and acquisition of expert perfor- mance: a general overview.Academic emergency medicine : official journal of the Society for Academic Emergency Medicine, 15 11, 988–94

    work page 2008

  9. [9]

    Alessandro Giagnorio, Alberto Martin-Lopez, and Gabriele Bavota. 2025. En- hancing code generation for low-resource languages: no silver bullet.arXiv preprint arXiv:2501.19085

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  10. [10]

    AgentCoder: Multi-Agent-based Code Generation with Iterative Testing and Optimisation

    Dong Huang, Jie M. Zhang, Michael Luck, Qingwen Bu, Yuhao Qing, and Hem- ing Cui. 2023. Agentcoder: multi-agent-based code generation with iterative testing and optimisation.arXiv preprint arXiv:2312.13010

    work page internal anchor Pith review Pith/arXiv arXiv 2023

  11. [11]

    Siming Huang et al. 2024. Opencoder: the open cookbook for top-tier code large language models. In https://arxiv.org/pdf/2411.04905

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  12. [12]

    Ashraful Islam, Mohammed Eunus Ali, and Md Rizwan Parvez

    Md. Ashraful Islam, Mohammed Eunus Ali, and Md Rizwan Parvez. 2025. CodeSim: multi-agent code generation and problem solving through simulation- driven planning and debugging. InFindings of the Association for Computational Linguistics: NAACL 2025. https://aclanthology.org/2025.findings-naacl.285.pdf

    work page 2025

  13. [13]

    Naman Jain et al. 2024. Livecodebench: holistic and contamination free evalua- tion of large language models for code.arXiv preprint arXiv:2403.07974

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  14. [14]

    Sathvik Joel, Jie Wu, and Fatemeh Fard. 2024. A survey on LLM-based code generation for low-resource and domain-specific programming languages. ACM Transactions on Software Engineering and Methodology

    work page 2024

  15. [15]

    Hung Le, Yue Wang, Akhilesh Deepak Gotmare, Silvio Savarese, and Steven Hoi. 2022. CodeRL: mastering code generation through pretrained models and deep reinforcement learning. InAdvances in Neural Information Processing Systems. Alice H. Oh, Alekh Agarwal, Danielle Belgrave, and Kyunghyun Cho, (Eds.) https://openreview.net/forum?id=WaGvb7OzySA

    work page 2022

  16. [16]

    Zi Lin, Sheng Shen, Jingbo Shang, Jason E Weston, and Yixin Nie. 2025. Learning to solve and verify: a self-play framework for mutually improving code and test generation. InNeurIPS 2025 Fourth Workshop on Deep Learning for Code

    work page 2025

  17. [17]

    Ziyang Luo et al. 2024. Wizardcoder: empowering code large language mod- els with evol-instruct. InThe Twelfth International Conference on Learning Representations

    work page 2024

  18. [18]

    Lu Ma et al. 2026. Learning what reinforcement learning can’t: interleaved online fine-tuning for hardest questions. InThe Fourteenth International Con- ference on Learning Representations. https://openreview.net/forum?id=LzCBLr NoyM

    work page 2026

  19. [19]

    Benjamin Pikus, Pratyush Ranjan Tiwari, and Burton Ye. 2025. Hard examples are all you need: maximizing grpo post-training under annotation budgets. arXiv preprint arXiv:2508.14094

    work page arXiv 2025

  20. [20]

    Ruchir Puri et al. 2021. Codenet: a large-scale AI for code dataset for learning a diversity of coding tasks. (2021). https://arxiv.org/abs/2105.12655 arXiv: 2105.12655[cs.SE]

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  21. [21]

    Shanghaoran Quan et al. 2025. Codeelo: benchmarking competition-level code generation of llms with human-comparable elo ratings.arXiv preprint arXiv:2501.01257

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  22. [22]

    Qwen Team. 2025. Qwen3 technical report.arXiv preprint arXiv:2505.09388

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  23. [23]

    Surangika Ranathunga, En-Shiun Annie Lee, Marjana Prifti Skenduli, Ravi Shekhar, Muhidin Alam, and Rishemjit Kaur. 2023. Neural machine translation for low-resource languages: a survey.ACM Computing Surveys, 55, 11, 1–37

    work page 2023

  24. [24]

    Houxing Ren et al. 2024. Reflectioncoder: learning from reflection sequence for enhanced one-off code generation.arXiv preprint arXiv:2405.17057

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  25. [25]

    Pengzhen Ren, Yun Xiao, Xiaojun Chang, Po-Yao Huang, Zhihui Li, Brij B Gupta, Xiaojiang Chen, and Xin Wang. 2021. A survey of deep active learning. ACM computing surveys (CSUR), 54, 9, 1–40

    work page 2021

  26. [26]

    Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, Y.K. Li, Y. Wu, and Daya Guo. 2024. Deepseekmath: pushing the limits of mathematical reasoning in open language models.arXiv preprint arXiv:2402.03300

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  27. [27]

    Parshin Shojaee, Aneesh Jain, Sindhu Tipirneni, and Chandan K. Reddy. 2023. Execution-based code generation using deep reinforcement learning.Transac- tions on Machine Learning Research. https://openreview.net/forum?id=0XBuax qEcG

    work page 2023

  28. [28]

    Lingxiao Tang, He Ye, Zhongxin Liu, Xiaoxue Ren, and Lingfeng Bao. 2025. Codereasoner: enhancing the code reasoning ability with reinforcement learn- ing. (2025). https://arxiv.org/abs/2507.17548 arXiv: 2507.17548[cs.SE]

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  29. [29]

    Hashimoto

    Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023. Stanford alpaca: an instruction-following llama model. https://github.com/tatsu-lab/stanford_alpa ca. (2023)

    work page 2023

  30. [30]

    Kaixin Wang, Tianlin Li, Xiaoyu Zhang, Aishan Liu, Xianglong Liu, Ziqi Liu, Zhiqiang Zhang, Jun Zhou, and Bin Shi. 2025. Codechemist: functional knowl- edge transfer for low-resource code generation via test-time scaling.ArXiv, abs/2510.00501. https://api.semanticscholar.org/CorpusID:281705760

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  31. [31]

    Yuxiang Wei, Zhe Wang, Jiawei Liu, Yifeng Ding, and Lingming Zhang. 2024. Magicoder: empowering code generation with OSS-instruct. InProceedings of the 41st International Conference on Machine Learning(Proceedings of Machine Learning Research). Vol. 235. PMLR, (July 2024), 52632–52657. https://proceedi ngs.mlr.press/v235/wei24h.html

    work page 2024

  32. [32]

    Zhangchen Xu, Yang Liu, Yueqin Yin, Mingyuan Zhou, and Radha Poovendran

    work page

  33. [33]

    KodCode: A Diverse, Challenging, and Verifiable Synthetic Dataset for Coding

    Kodcode: a diverse, challenging, and verifiable synthetic dataset for coding. https://arxiv.org/abs/2503.02951 arXiv: 2503.02951[cs.LG]

    work page internal anchor Pith review Pith/arXiv arXiv

  34. [34]

    Qiying Yu et al. 2025. Dapo: an open-source llm reinforcement learning system at scale.ArXiv, abs/2503.14476

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  35. [35]

    Yi Zhang et al. 2025. Bridging vlms and embodied intelligence with deliberate practice policy optimization.ArXiv, abs/2511.16602

    work page arXiv 2025