Pith. sign in

REVIEW 4 major objections 5 minor 2 cited by

Repository Structure-Aware Training Makes SLMs Better Issue Resolver

T0 review · 4 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Repository structure-aware training lifts a small code model's issue-fixing rate on SWE-Bench-verified from 0.8% to 7.2%.

desk verdict ReSAT gives a real gain for 7B models on SWE-Bench-verified, but the paper does not isolate whether the structure-aware decomposition is the cause rather than generic SFT on issue-fix data. read the letter →

arxiv 2412.19031 v1 pith:MHMB5WGH submitted 2024-12-26 cs.SE cs.AI

Zexiong Ma , Shengnan An , Zeqi Lin , Yanzhen Zou , Bing Xie This is my paper · ORCID
classification cs.SEcs.AI
keywords ReSATrepositorystructure-awaretrainingsmalllanguagemodelsissueresolvinglocalizationcodeeditSWE-Bench-verifiedRepoQA
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper introduces ReSAT, a fine-tuning recipe that teaches small language models (13 billion parameters or fewer) to resolve real software issues by exploiting the structure of code repositories. The authors automatically collect 80,260 training samples from 229 popular open-source Python projects by linking resolved issues to the pull requests that fixed them, then organize each sample into four supervised tasks: locate the files, locate the functions, locate the lines, and produce the code edit. On SWE-Bench-verified—a benchmark of real repository issues with executable tests—ReSAT raises the resolved-issue rate of CodeQwen1.5-7B-Chat from 0.8% to 7.2% and of Deepseek-Coder-6.7B-Instruct from 1.8% to 6.6%. Both models also gain on the RepoQA long-context benchmark, including in languages other than Python. The paper's thesis is that hierarchical localization practice, not raw code exposure, is what makes small models better issue resolvers.

What carries the argument

The load-bearing object is the multi-level progressive localization dataset. It consists of (1) file-level localization, where the input is the issue plus the repository file tree and the output is the modified files; (2) function-level localization, where the input is the issue plus a file skeleton built from class and function declarations and the output is the modified functions; (3) line-level localization, where the input is the issue plus the full function content, with distractor functions added, and the output is the exact modified lines; and (4) code edit generation, where the input is the issue plus the localized snippet and the output is a Search/Replace edit. This hierarchy mirrors the inference-time steps of the Agentless framework, so fine-tuning on it is intended to teach the model to decompose a repository into candidate locations before making changes.

What would settle it

Train the same two base models on the same 80,260 issue-to-edit samples but flatten the supervision—use only issue-to-diff or issue-to-modified-file pairs instead of the file/function/line hierarchy. If the flat models match ReSAT's 7.2% and 6.6% resolved rates on SWE-Bench-verified, the hierarchy is not the active ingredient; if the flat models fall back to the 0.8%–1.8% range, the structure-aware decomposition is what carries the gain.

Watch

Extended reading notes

Core claim

The central claim is that supervised fine-tuning on repository-structure information can substantially improve small models' ability to solve real-world coding issues, without resorting to larger models or agentic scaffolding. The authors call the recipe ReSAT and build it from real merged pull requests: for each issue, the training target is the set of files modified by the fix, the set of functions modified within those files, the set of lines modified within those functions, and the final Search/Replace edit. Trained on this data, CodeQwen1.5-7B-Chat and Deepseek-Coder-6.7B-Instruct both show large jumps in resolved issues on SWE-Bench-verified when used inside the Agentless pipeline—a two-phase framework that first localizes relevant code and then generates edits—and improved accuracy on RepoQA. The paper interprets the ablation result—localization data alone helps more than edit data alone, and the two combine best—as evidence that the structure-aware localization task is the active ingredient.

Load-bearing premise

The load-bearing premise is that the automatically scraped issue-pull-request pairs carry correct, transferable supervision, and that the measured gains come from the structure-aware hierarchy rather than from extra fine-tuning on similar issue-fix data.

Editorial extensions

If this is right

  • A 7B-parameter model fine-tuned with ReSAT resolves 7.2% of SWE-Bench-verified issues through Agentless, a roughly ninefold improvement over the untrained CodeQwen baseline.
  • Localization data contributes more to the gains than code-edit data does, and using both together gives the best result, so the two training objectives are complementary.
  • Training on Python-only ReSAT data improves RepoQA accuracy in C++, Rust, Java, and TypeScript, suggesting the learned localization skill transfers across programming languages.
  • ReSAT narrows but does not close the gap with much larger commercial models on the same pipelines.
  • ReSAT-trained small models solve some issues that a frontier model fails on, so small and large models can complement each other in an issue-resolving system.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A direct control that would separate the structure-aware contribution from generic supervised fine-tuning is to train on the same 80,260 issue-edit pairs with the hierarchy flattened; until that control is run, part of the gain should be attributed to additional supervised fine-tuning on real issue-fix data.
  • Because the issue–pull-request links are extracted by regular expressions from titles and commit messages, some fraction of the 80,260 samples is likely mislabeled, so link cleaning and denoising are a natural next step that could raise the measured ceiling.
  • The same file/function/line/edit hierarchy can be generated from any diff, so ReSAT-style objectives could transfer to other repository-level tasks such as code review, refactoring, or test generation.
  • Since Python-only ReSAT data improves RepoQA in four other languages, training on multilingual issue-fix pairs is an obvious extension; whether SWE-Bench-style resolution gains transfer to non-Python repositories remains an open test.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper introduces ReSAT (Repository Structure-Aware Training), a method for constructing training data from GitHub issues and pull requests to improve the repository-level issue-resolving and long-context understanding capabilities of small language models (SLMs). The data consists of multi-level localization tasks (file, function, line) and code-edit tasks. The authors fine-tune CodeQwen1.5-7B-Chat and Deepseek-Coder-6.7B-Instruct, evaluate on SWE-Bench-verified and RepoQA, and report substantial improvements in %Resolved (e.g., from 0.8% to 7.2% for CodeQwen under Agentless). Ablation studies on single-task data are presented, along with a case study and comparisons with LLM-based baselines in the appendix.

Significance. If the reported gains are robust, ReSAT provides a low-cost, LLM-free approach to improving SLMs on repository-level tasks, and the paper offers a concrete data-construction pipeline that the community could build on. The evaluation covers two SLMs, two issue-resolving frameworks, and a long-context benchmark, and the authors exclude SWE-Bench and RepoQA repositories from the training data, reducing direct leakage. The ablation study separates the contribution of localization versus code-edit data. However, the paper's central causal claim — that the structure-aware decomposition is the operative ingredient — is not isolated, and several evaluation gaps (single runs, unexplained per-language drops) prevent the evidence from fully supporting that claim as stated.

major comments (4)
  1. [§3.4 / Figure 3] The paper's main claim is that structure-aware training (the multi-level file/function/line decomposition) is the cause of the gains, but no control is trained on the same raw issue-edit pairs without this decomposition. The ablation in Figure 3 shows that both only-edit (0.8→1.8) and only-localization (0.8→4.8) improve over the base model, so any supervised fine-tuning on similar GitHub issue-fix data could plausibly account for part or all of the improvement. Without a flat-SFT control on the same PR-derived data, the attribution to structure awareness is not isolated.
  2. [§4.5 / Table 2] The per-language RepoQA results contain a large, unexplained drop for Deepseek-Coder on C++ (from 21 to 14) and a smaller drop for CodeQwen on TypeScript (67 to 65). The text states that ReSAT improves accuracy in most languages, which is true, but the C++ drop is substantial and should be discussed or analyzed. This is particularly relevant because the paper argues that Python-only training improves cross-lingual understanding, and a decline in one language weakens that claim without an explanation.
  3. [§4.2 / Table 1] All experiments appear to be single runs with no confidence intervals or significance tests. Because SWE-Bench-verified has 500 tasks, the reported differences are small in absolute terms (e.g., 0.8% vs 7.2% corresponds to 4 vs 36 issues, and a 0.8% change is about 4 issues). The paper should either provide variance estimates from repeated runs or acknowledge the sensitivity of these percentages to small absolute changes and discuss whether the observed gaps are statistically meaningful.
  4. [§3.1] The data-construction pipeline links issues to PRs using regular expressions on PR titles and commit messages, with no manual verification or filtering for whether the PR indeed resolves the mentioned issue. This introduces label noise in the supervisions signals, and the paper does not quantify the quality of these automatically generated links. A small human-validated sample or a heuristic check (e.g., whether the PR diff touches files related to the issue text) would help establish the reliability of the 80,260 samples.
minor comments (5)
  1. [Throughout] The manuscript contains numerous typographical errors and formatting inconsistencies, including 'flollow', 'furute', 'utilze', 'lanuages', 'Pull Requets', 'webaset', and 'capibility'. A thorough proofreading pass is needed.
  2. [Figure 3] The figure lacks error bars or any indication of run-to-run variance, which is especially important given the small absolute numbers in the SWE-Bench-verified results.
  3. [Appendix B, Table 4] The comparison with SWE-Llama and CodeQwen-Opendevin confounds the training method with the inference framework and the underlying base model; this is acknowledged in the text, but it would be clearer to present it strictly as an end-to-end comparison and not as evidence specifically for ReSAT's data-construction choices.
  4. [§3.2.3] The description of line-localization data says that 'we introduce irrelevant functions as distractions' and also includes the modified function name in the output; this conflates function-level and line-level localization and should be described more precisely to avoid ambiguity about the task format.
  5. [§4.1] The paper states that RepoQA has 500 test samples across five languages; providing the per-language sample counts would help assess the reliability of the per-language accuracies reported in Table 2.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular dependency: training and evaluation are disjoint, and no reported gain is fixed by construction.

full rationale

The paper's contribution is an empirical fine-tuning pipeline, not a formal derivation whose conclusion is encoded in its premises. ReSAT scrapes 44,088 PRs from 229 popular Python repositories, explicitly excludes any repository appearing in the SWE-Bench or RepoQA test sets (Section 3.1), constructs file/function/line localization and code-edit supervision from the PR diffs, fine-tunes CodeQwen1.5-7B-Chat and Deepseek-Coder-6.7B-Instruct, and evaluates on the held-out SWE-Bench-verified and RepoQA benchmarks. The reported metrics (% Resolved, % FileHit, % FuncHit, % LineHit, RepoQA Accuracy) are computed on test repositories that are not part of the training scrape, so the gains are empirical transfer results rather than predictions of the training labels. No equation or definition makes a test outcome equal to a training target, and no parameter is fitted to the benchmark and then reported as a prediction. The two self-citations (An et al. 2023; Ma et al. 2024) appear only in related work and are not load-bearing. The main weakness is the absence of a flat-SFT control trained on the same issue-edit pairs without the hierarchical decomposition; the ablation in Section 4.5.1 compares onlyEdit, onlyLoc, and full ReSAT, but not raw issue-to-diff supervision. That is a causal-isolation limitation, not a circularity step: the full model's improved performance is an empirical outcome, not an identity.

Assumptions & free parameters 4 free parameters · 5 assumptions · 0 invented entities

The paper's claims rest on the quality and transferability of automatically scraped issue-PR supervision. There are no new physical entities or fitted constants; the free parameters are training and data-filtering choices.

free parameters (4)
  • Repository popularity thresholds = >= 1,000 stars and >= 1,000 PRs; top 5,000 PyPI packages
    Hand-chosen criteria for selecting 229 repositories; affects the training distribution but is not a derived constant.
  • Context length cutoff = 32k tokens
    Training samples longer than 32k tokens are discarded; a practical resource limit.
  • Training epochs = 2
    All models are trained for 2 epochs; no tuning is reported.
  • Maximum learning rate = 5e-6
    Cosine schedule with 3% warmup; chosen without reported hyperparameter search.
assumptions (5)
  • domain assumption PRs linked to issues via regex on title and commit messages are genuine fixes for those issues.
    Section 3.1: issue numbers are extracted with regular expressions; no manual validation of the 44,088 PRs is reported.
  • domain assumption Popularity (downloads, stars, PR count) selects high-quality repositories whose issue-fix pairs teach useful localization and editing.
    Section 3.1: repository selection filters on downloads, stars, and PR counts following Jimenez et al. (2024).
  • domain assumption The automatically extracted modified files, functions, and lines from a PR are the correct supervision targets.
    Section 3.2: file, function, and line labels are derived from diffs and libcst parsing, without manual verification.
  • domain assumption SWE-Bench-verified and RepoQA are valid and sufficient measures of issue-resolving and long-context understanding.
    Section 4.1: the paper uses these benchmarks as the sole evidence for the central claim.
  • ad hoc to paper Excluding test files and non-Python files from the data improves training for Python issue resolution.
    Section 3.2.1: this filtering choice is specific to ReSAT and is not justified by comparison experiments.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Repository Structure-Aware Training Makes SLMs Better Issue Resolver." pith.science (2026). https://pith.science/paper/MHMB5WGH

@misc{pith2026241219031,
  author       = {Pith},
  title        = {Pith review of: Repository Structure-Aware Training Makes SLMs Better Issue Resolver},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MHMB5WGH}},
  note         = {Machine review of arXiv:2412.19031}
}
read the original abstract

Language models have been applied to various software development tasks, but the performance varies according to the scale of the models. Large Language Models (LLMs) outperform Small Language Models (SLMs) in complex tasks like repository-level issue resolving, but raise concerns about privacy and cost. In contrast, SLMs are more accessible but under-perform in complex tasks. In this paper, we introduce ReSAT (Repository Structure-Aware Training), construct training data based on a large number of issues and corresponding pull requests from open-source communities to enhance the model's understanding of repository structure and issue resolving ability. We construct two types of training data: (1) localization training data, a multi-level progressive localization data to improve code understanding and localization capability; (2) code edit training data, which improves context-based code editing capability. The evaluation results on SWE-Bench-verified and RepoQA demonstrate that ReSAT effectively enhances SLMs' issue-resolving and repository-level long-context understanding capabilities.

Figures

Figures reproduced from arXiv: 2412.19031 by the authors.

Figure 2
Figure 2. ReSAT training data scraping, construction and training pipeline. We first scrape issues and PRs from [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Ablation study on training datasets. The first four figures show the metrics on SWE-bench-verified. The [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figure 4
Figure 4. Case study. IDEs, allowing LMs to automatically invoke these ACIs to edit files, navigate repositories, and ex￾ecute tests. Chen et al. (2024) proposed CodeR, which distributes tasks to different agents based on a task graph, addressing issues through multi-agent collaborations. Pipeline-based systems (Xia et al., 2024; Jimenez et al., 2024; Liang et al., 2024; Shrivas￾tava et al., 2023) follow a streamlined two-pha… view at source ↗
Figures from the paper (1 more)
Figure 5
Figure 5. Figure 5: Comparison results between RAG-SWE with ReSAT-trained SLMs and LLMs. [PITH_FULL_IMAGE:figures/full_fig_p013_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. WebGen-Bench: Evaluating LLMs on Generating Interactive and Functional Websites from Scratch

    cs.CL 2025-05 conditional novelty 7.0 of 10

    WebGen-Bench provides 101 website-building tasks with 647 atomic test cases, and a trained Qwen2.5-Coder-32B model reaches 38.2% accuracy, outperforming DeepSeek-R1's 27.8%.

  2. MCTS-Refined CoT: High-Quality Fine-Tuning Data for LLM-Based Repository Issue Resolution

    cs.SE 2025-06 conditional novelty 5.0 of 10

    MCTS-REFINE uses tree search plus strict ground-truth matching to build chain-of-thought training data that lifts open-source LLM issue-resolution scores on SWE-bench.

Reference graph

Works this paper leans on

44 extracted references · 9 canonical work pages · cited by 2 Pith papers

  1. [1]

    2022. Chatgpt. https://chat.openai.com/

    work page 2022

  2. [2]

    Github copilot

    2022. Github copilot. https://github.com/features/copilot

    work page 2022

  3. [3]

    2023. Gpt-4. https://openai.com/index/gpt-4-research/

    work page 2023

  4. [4]

    Introducing the next generation of claude

    2024. Introducing the next generation of claude. https://www.anthropic.com/news/claude-3-family

    work page 2024

  5. [5]

    Shengnan An, Zexiong Ma, Zeqi Lin, Nanning Zheng, Jian-Guang Lou, and Weizhu Chen. 2023. Learning from mistakes makes llm better reasoner. arXiv preprint arXiv:2310.20689

    arXiv 2023

  6. [6]

    Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732

    arXiv 2021

  7. [7]

    Ramakrishna Bairi, Atharv Sonwane, Aditya Kanade, Arun Iyer, Suresh Parthasarathy, Sriram Rajamani, B Ashok, and Shashank Shet. 2024. Codeplan: Repository-level coding using llms and planning. Proceedings of the ACM on Software Engineering, 1(FSE):675--698

    2024

  8. [8]

    Dong Chen, Shaoxin Lin, Muhan Zeng, Daoguang Zan, Jian-Gang Wang, Anton Cheshkov, Jun Sun, Hao Yu, Guoliang Dong, Artem Aliev, et al. 2024. Coder: Issue resolving with multi-agent and task graphs. arXiv preprint arXiv:2406.01304

    arXiv 2024

Show all 44 references
  1. [9]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

    2021 arXiv

  2. [10]

    Cognition. 2024. https://www.cognition.ai/blog/introducing-devin Introducing devin

    2024

  3. [11]

    Tri Dao. 2024. Flash A ttention-2: Faster attention with better parallelism and work partitioning. In International Conference on Learning Representations (ICLR)

    2024

  4. [12]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, YK Li, et al. 2024. Deepseek-coder: When the large language model meets programming--the rise of code intelligence. arXiv preprint arXiv:2401.14196

    2024 arXiv

  5. [13]

    Sirui Hong, Xiawu Zheng, Jonathan Chen, Yuheng Cheng, Jinlin Wang, Ceyao Zhang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, et al. 2023. Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv:2308.00352

    2023 arXiv

  6. [14]

    Yoichi Ishibashi and Yoshimasa Nishimura. 2024. Self-organized agents: A llm multi-agent framework toward ultra large-scale code generation and optimization. arXiv preprint arXiv:2404.02183

    2024 arXiv

  7. [15]

    Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. 2024. A survey on large language models for code generation. arXiv preprint arXiv:2406.00515

    2024 arXiv

  8. [16]

    Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik R Narasimhan. 2024. https://openreview.net/forum?id=VTF8yNQM66 SWE -bench: Can language models resolve real-world github issues? In The Twelfth International Conference on Learning Re...

    2024

  9. [17]

    Matthew Jin, Syed Shahriar, Michele Tufano, Xin Shi, Shuai Lu, Neel Sundaresan, and Alexey Svyatkovskiy. 2023. Inferfix: End-to-end program repair with llms. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Softw...

    2023

  10. [18]

    Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, R \'e mi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, et al. 2022. Competition-level code generation with alphacode. Science, 378(6624):1092--1097

    2022

  11. [19]

    Ming Liang, Xiaoheng Xie, Gehao Zhang, Xunjin Zheng, Peng Di, Hongwei Chen, Chengpeng Wang, Gang Fan, et al. 2024. Repofuse: Repository-level code completion with fused dual context. arXiv preprint arXiv:2402.14323

    2024 arXiv

  12. [20]

    Jiawei Liu, Jia Le Tian, Vijay Daita, Yuxiang Wei, Yifeng Ding, Yuhan Katherine Wang, Jun Yang, and Lingming Zhang. 2024. Repoqa: Evaluating long context code understanding. arXiv preprint arXiv:2406.06025

    2024 arXiv

  13. [21]

    Tianyang Liu, Canwen Xu, and Julian McAuley. 2023. Repobench: Benchmarking repository-level code auto-completion systems. arXiv preprint arXiv:2306.03091

    2023 arXiv

  14. [22]

    Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy-Poirier, Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, et al. 2024. Starcoder 2 and the stack v2: The next generation. arXiv preprint arXiv:2402.19173

    2024 arXiv

  15. [23]

    Qinyu Luo, Yining Ye, Shihao Liang, Zhong Zhang, Yujia Qin, Yaxi Lu, Yesai Wu, Xin Cong, Yankai Lin, Yingli Zhang, et al. 2024. Repoagent: An llm-powered open-source framework for repository-level code documentation generation. arXiv preprint arXiv:2402.16667

    2024 arXiv

  16. [24]

    Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. 2023. Wizardcoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568

    2023 arXiv

  17. [25]

    Zexiong Ma, Shengnan An, Bing Xie, and Zeqi Lin. 2024. Compositional api recommendation for library-oriented code generation. In Proceedings of the 32nd IEEE/ACM International Conference on Program Comprehension, pages 87--98

    2024

  18. [26]

    Niklas Muennighoff, Qian Liu, Armel Zebaze, Qinkai Zheng, Binyuan Hui, Terry Yue Zhuo, Swayam Singh, Xiangru Tang, Leandro Von Werra, and Shayne Longpre. 2023. Octopack: Instruction tuning code large language models. arXiv preprint arXiv:2308.07124

    2023 arXiv

  19. [27]

    OpenAI. 2024. https://openai.com/index/introducing-swe-bench-verified/ Swe-bench-verified

    2024

  20. [28]

    Qiwei Peng, Yekun Chai, and Xuhong Li. 2024. Humaneval-xl: A multilingual code generation benchmark for cross-lingual natural language generalization. arXiv preprint arXiv:2402.16694

    2024 arXiv

  21. [29]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950

    2023 arXiv

  22. [30]

    Disha Shrivastava, Hugo Larochelle, and Daniel Tarlow. 2023. Repository-level prompt generation for large language models of code. In International Conference on Machine Learning, pages 31693--31715. PMLR

    2023

  23. [31]

    Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, L \'e onard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ram \'e , et al. 2024. Gemma 2: Improving open language models at a practical size. arXiv preprint arXiv:2408.00118

    2024 arXiv

  24. [32]

    Qwen Team. 2024. https://qwenlm.github.io/blog/codeqwen1.5/ Code with codeqwen1.5

    2024

  25. [33]

    Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timoth \'e e Lacroix, Baptiste Rozi \`e re, Naman Goyal, Eric Hambro, Faisal Azhar, et al. 2023. Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971

    2023 arXiv

  26. [34]

    Xingyao Wang, Boxuan Li, Yufan Song, Frank F Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, et al. 2024. Opendevin: An open platform for ai software developers as generalist agents. arXiv preprint arXiv:2407.16741

    2024 arXiv

  27. [35]

    Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2022. Self-instruct: Aligning language models with self-generated instructions. arXiv preprint arXiv:2212.10560

    2022 arXiv

  28. [36]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. 2022. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824--24837

    2022

  29. [37]

    Yuxiang Wei, Zhe Wang, Jiawei Liu, Yifeng Ding, and Lingming Zhang. 2024. Magicoder: Empowering code generation with oss-instruct. In Forty-first International Conference on Machine Learning

    2024

  30. [38]

    Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Shaokun Zhang, Erkang Zhu, Beibin Li, Li Jiang, Xiaoyun Zhang, and Chi Wang. 2023. Autogen: Enabling next-gen llm applications via multi-agent conversation framework. arXiv preprint arXiv:2308.08155

    2023 arXiv

  31. [39]

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2024. Agentless: Demystifying llm-based software engineering agents. arXiv preprint arXiv:2407.01489

    2024 arXiv

  32. [40]

    Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, Qingwei Lin, and Daxin Jiang. 2024. Wizardlm: Empowering large pre-trained language models to follow complex instructions. In The Twelfth International Conference on Learning Representations

    2024

  33. [41]

    John Yang, Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. Swe-agent: Agent-computer interfaces enable automated software engineering. arXiv preprint arXiv:2405.15793

    2024 arXiv

  34. [42]

    P Xing, Hao Zhang, Joseph E

    Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric. P Xing, Hao Zhang, Joseph E. Gonzalez, and Ion Stoica. 2023. https://arxiv.org/abs/2306.05685 Judging llm-as-a-judge with mt-bench and chatbot arena . P...

    2023 arXiv

  35. [43]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  36. [44]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.