Pith. sign in

REVIEW 4 major objections 6 minor 21 references

SACL: Understanding and Combating Textual Bias in Code Retrieval with Semantic-Augmented Reranking and Localization

T0 review · 4 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read This paper shows that code retrievers rely on surface textual cues rather than code semantics, and that augmenting code with LLM-generated descriptions substantially improves retrieval and downstream code generation.

desk verdict The normalization analysis is a solid diagnostic, but the SACL effectiveness claims are supported only under synthetic normalization, and Table 4 has a likely error. read the letter →

arxiv 2506.20081 v2 pith:MKRP6J24 submitted 2025-06-25 cs.CL cs.AI

Dhruv Gupta , Gayathri Ganesh Lakshmy , Yiqing Xie This is my paper
classification cs.CLcs.AI
keywords coderetrievaltextualbiassemanticaugmentationrerankingfaultlocalizationretrieval-augmentedgenerationnormalizationanalysisLLM-generateddescriptions
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 aims to establish that current code retrievers are biased toward surface-level textual features—docstrings and identifier names—rather than code functionality, and that this bias can be partially corrected by augmenting code with semantic descriptions. The authors demonstrate the bias through a normalization analysis that replaces docstrings, function names, and variable names with placeholders while preserving behavior, causing recall to collapse (e.g., GIST-large Recall@1 on MBPP drops from 98.6% to 9.0%). They then propose SACL, which reranks retrieved code using a weighted combination of code–query similarity and similarity between the query and an LLM-generated description of each code snippet, and augments repository tree structures with file descriptions for localization. On HumanEval, MBPP, and SWE-Bench-Lite, SACL reports substantial retrieval and localization gains that also improve code generation Pass@1. The work matters because retrieval quality is a known bottleneck in retrieval-augmented code generation, and the proposed fix requires no retraining of the retriever.

What carries the argument

The load-bearing mechanism is the normalization-based analysis framework combined with semantic augmentation. Normalization systematically strips textual cues (docstrings, function names, variable names) from code while preserving its functionality, which isolates how much retrievers depend on surface text. Semantic augmentation then generates a concise natural-language description of each retrieved code snippet or repository file using an 8B-parameter LLM, and reranks by the weighted score $\text{Score}_{\text{final}} = (1-\alpha)\,\text{Score}_{\text{code}} + \alpha\,\text{Score}_{\text{desc}}$ with $\alpha=0.7$, turning text-to-code comparison into text-to-text comparison. For repository-level localization, the same idea is applied to the file tree, where each file is annotated with a generated description of its purpose and relationships, supplying the LLM with semantic context that filenames alone lack.

What would settle it

Normalize the queries as well as the documents (or evaluate on naturally under-documented code with docstrings and identifier names removed before indexing) and rerun the retrieval experiments; if Recall@1 no longer collapses under full normalization, or if irrelevant well-documented documents are no longer preferred, the claimed bias is an artifact of the asymmetric setup rather than a property of current code retrievers.

Watch

Extended reading notes

Core claim

The paper's central discovery is that code retrievers, despite being trained on code, predominantly match queries to documents by textual overlap rather than by functional equivalence. Using normalization—replacing docstrings, function names, and variable names with placeholders—the paper finds that Recall@1 degrades sharply for both embedding-based retrievers and LLM-based rerankers, and that the degradation is worst when only the ground-truth document is normalized while the rest of the corpus remains well-documented. That asymmetry shows a bias toward well-documented code even when the documentation is irrelevant. To counter this, the paper proposes semantic-augmented code reranking and semantic-augmented in-context localization: generated descriptions of code and repository files are combined with original retrieval scores ($\alpha=0.7$ weight on description similarity), and augmented repo trees are fed to an LLM for file localization. The reported improvements are up to 12.8% Recall@1 on HumanEval, 9.4% on MBPP under full normalization, and up to 8.0% file-localization accuracy on SWE-Bench-Lite, with corresponding gains in code generation.

Load-bearing premise

The bias analysis assumes that normalizing only the code documents, not the queries, is a fair way to measure what retrievers rely on; if that asymmetry itself creates the drop, the bias claim is overstated.

Editorial extensions

If this is right

  • If the bias claim is right, retrieval-augmented code generation from real-world, sparsely documented codebases will systematically retrieve the wrong code, and SACL's description-based reranking should recover much of that loss without retraining or changing the retriever.
  • The finding that benefits are largest on MBPP (low lexical overlap) and under full normalization implies that the method's value scales with how poorly the corpus is documented.
  • Because SACL improves file localization within the Agentless pipeline, repo-level fault localization should improve even when the underlying LLM is unchanged, raising issue-resolution rates on benchmarks like SWE-Bench-Lite.
  • The code-generation pass-through (up to 4.88% Pass@1 on HumanEval under full normalization) suggests that fixing retrieval bias directly improves downstream generation quality.
  • Peak performance at $\alpha=0.7$ rather than at pure code retrieval ($\alpha=0$) or pure description retrieval ($\alpha=1$) indicates that code and description signals carry complementary information, so hybrid reranking is the robust choice.

Reading between the lines

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

  • Because the normalization experiments leave queries untouched, the measured bias may be partly an artifact of asymmetric normalization; a cleaner test would normalize queries and documents together to see whether the bias claim survives.
  • Since descriptions are generated by an 8B model, the description-query scores could be distilled into the base retriever, making semantic awareness available at inference time without an LLM call.
  • The same description-augmentation idea could transfer to other structured inputs, such as API schemas or configuration files, where LLMs must ground decisions in repository context.
  • The gains are measured under artificial normalization; on naturally documented codebases the practical margin may be smaller, so the real-world impact depends on how under-documented common corpora actually are.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 6 minor

Summary. The paper analyzes code retrieval systems by systematically normalizing textual features (docstrings, function/variable names) while preserving functionality, and reports two discoveries: (1) retrievers rely heavily on surface-level textual features rather than functional semantics, and (2) they are biased toward well-documented code even when the documentation is irrelevant. Based on these findings, the authors propose SACL, a framework that augments code retrieval with LLM-generated natural-language descriptions and uses semantic-augmented in-context localization for repository-level fault localization. They report substantial Recall@1 gains on HumanEval/MBPP under normalization settings, file-localization gains on SWE-Bench-Lite, and downstream Pass@1 improvements. The paper includes controlled experiments across embedding retrievers and LLM rerankers, several case studies, and an analysis of why the approach works in terms of lexical overlap.

Significance. If the bias diagnosis and the effectiveness claims were fully established, this work would make a useful contribution to code retrieval research by showing that current embedding-based retrievers and LLM rerankers rely heavily on lexical signals, and by offering a concrete reranking strategy. The controlled normalization framework is a valuable analytical tool, and the case studies illustrate qualitative failures that are easy to understand. However, the significance is weakened by three problems: the headline retrieval gains are measured only under synthetic asymmetric normalization, the unnormalized HumanEval retrieval gain is zero, and the SWE-Bench-Lite result is a file-localization accuracy on 300 instances without significance testing. The paper does not provide machine-checked proofs or released code; its value rests on the empirical claims, which are currently only partially supported. With additional real-world evaluation and proper controls, the core ideas could be a solid contribution; as presented, the evidence is not sufficient for the strength of the abstract claims.

major comments (4)
  1. [§2.1–2.2, Tables 1–2] The normalization experiments are asymmetric: only the code documents are normalized, while the natural-language queries are left in their original form. Because the original query retains docstring words and identifier names, normalizing the positive document removes exactly the lexical overlap that the query depends on. The dramatic drops (e.g., 98.6% to 9.0% Recall@1 on MBPP) and the corresponding SACL gains may therefore be artifacts of this artificially created lexical mismatch, not evidence of a learned preference for surface features over semantics. Figure 4 supports this reading: SACL improves retrieval by increasing ROUGE-1 overlap between query and positive descriptions, i.e., by restoring the lexical signal that the experiment removed. To support the bias claim, the authors should include a symmetric control where both queries and documents are normalized, and should additionally evaluate on naturally sparse or poorly documented code rather than only synthetic normalization.
  2. [Abstract and Table 2] The headline claim that SACL 'substantially improves code retrieval (e.g., by 12.8% / 9.4% / 7.0% Recall@1 on HumanEval / MBPP / SWE-Bench-Lite)' is misleading because the HumanEval and MBPP numbers are obtained under the full-normalization setting, not on original code. On unnormalized HumanEval retrieval, the reported gain is 0.0 (Table 2, Docstring row: 98.8 to 98.8), and no result for original code is reported. The abstract and introduction should clearly separate gains on synthetic normalized corpora from gains on naturally occurring code, and the paper should report the unnormalized baseline and SACL performance explicitly. Without this, a reader cannot judge whether SACL helps in realistic retrieval scenarios.
  3. [Table 3 and §4.2] The SWE-Bench-Lite '7.0% Recall@1' improvement is not a retrieval Recall@1 comparable to the HumanEval/MBPP results; it is the file-localization accuracy of the Agentless pipeline (i.e., whether the localized files contain the ground-truth patch locations). This is an important distinction because the localization step is an LLM prompt, not a retrieval metric. Moreover, the result is based on only 300 instances, with no confidence intervals, variance estimates, or significance tests. The difference between 79.0% and 86.0% (or 70.0% to 78.0%) could be within run-to-run variation of the Agentless pipeline. The authors should report multiple runs or a significance test and should clearly label the metric as file-localization accuracy rather than Recall@1.
  4. [§4.4, Figure 5, and §A.1] The hyperparameter α in Equation (1) is selected to maximize Recall@k on the same test benchmarks (HumanEval and MBPP), as shown in Figure 5, and the final results use α=0.7 (Appendix A.1). No validation split or independent tuning procedure is described. Since the gains are strongly dependent on α (with peaks at 0.7 and lower performance for α=0 or α=1), the reported improvements may be optimistically biased by test-set tuning. The paper should describe how α was chosen (e.g., on a held-out validation set) or provide a sensitivity analysis that does not rely on the test set.
minor comments (6)
  1. [Abstract] Please clarify that the HumanEval/MBPP numbers are under full normalization, and that the SWE-Bench-Lite number is file-localization accuracy, not a retrieval Recall@1 in the same sense.
  2. [Table 2] The row labels 'Docstring', 'Func Name', and 'All' are ambiguous. They should be defined explicitly (e.g., 'remove docstrings', 'remove docstrings + rename functions', 'remove docstrings + rename functions and variables'), and a row for the original unnormalized code should be added.
  3. [Figure 2] The order of normalization types is inconsistent between the retrieval panels ('Base Docstr Var Fn Full') and the reranking panels ('Base Docstr Fn Var Full'), which makes it hard to compare the plots. Please use the same order in all panels and add axis labels.
  4. [Section 3.1] Equation (1) introduces α but does not say how it should be set in practice; Appendix A.1 states α=0.7, but the paper should note whether this value transfers across datasets or is tuned per benchmark.
  5. [Table 4] The text emphasizes the 4.88% Pass@1 gain on HumanEval, but Table 4 shows the gain is zero under the Docstring and Func Name settings and appears only under 'All' normalization. Please state this explicitly so the reader understands the synthetic conditions under which the generation gains are obtained.
  6. [Conclusion and Limitations] The limitations paragraph is helpful, but it does not address the asymmetric normalization confound or the small scale of the SWE-Bench-Lite evaluation; please add those caveats to the limitations section.

Circularity Check

1 steps flagged · score 4.0 of 10

No equation-level circularity in the bias analysis, but the headline retrieval gains are partially fitted: the reranking weight α is selected on the same HumanEval/MBPP test sets whose Recall@1 improvements are then reported as SACL's main results.

  1. fitted input called prediction [Section 4.4 (Hyper-Parameter Analysis) and Appendix A.1 (Implementation Details), Eq. (1)]
    "As shown in Figure 5, for all Recall@ k values (k=1, 5, 10), the performance consistently peaks at α=0.7, except in the case of docstring normalization, where all methods perform nearly perfectly. ... For reranking, we combine the embedding similarity scores from both code and descriptions using Equation 1 with α = 0.7."

    The α in Eq. (1) is chosen by inspecting Recall@k curves on the HumanEval and MBPP test benchmarks (Figure 5), and the same benchmarks' Recall@1 gains are then presented (Table 2; Abstract: 12.8%/9.4%) as evidence that SACL 'substantially improves code retrieval'. The reported improvements are therefore not out-of-sample predictions: they are the output of selecting the interpolation weight on the evaluation set itself, so the headline retrieval gains are in part statistically forced by the selection procedure. The SWE-Bench-Lite localization gains and code-generation results do not depend on this α, so the circularity is partial rather than total.

full rationale

The paper is an empirical analysis rather than a formal derivation, so there is no equation-level self-definition. The normalization manipulations in Section 2 are controlled interventions (removing docstrings/renaming identifiers) and the observed Recall@1 drops directly support the claim that the tested retrievers rely on surface lexical features; that inference is not circular. The SACL reranking formula is a weighted combination of code and description scores, and the paper's own Figure 4 candidly shows that the mechanism is increased ROUGE-1 lexical overlap, which undercuts the 'semantic understanding' framing but is not a circularity. No load-bearing self-citation is present: the Wang et al. (2025) citation with overlapping authorship is only used for evaluation conventions. The main circular concern is the test-set selection of α described in the step above. The asymmetric-normalization setup (queries untouched, documents normalized) is a methodological threat to external validity rather than a circularity, and the SWE-Bench-Lite result is reported as file-localization accuracy rather than Recall@1, which is a reporting error, not a circular step.

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

No new theoretical entities are introduced. The method's load-bearing choices are the fitted interpolation weight alpha, the top-k context size, and the assumption that scrubbing identifiers isolates textual bias. The four listed axioms are unproved background assumptions that the central interpretation relies on.

free parameters (2)
  • alpha (reranking interpolation weight) = 0.7
    Equation 1 combines code score and description score; Figure 5 shows performance peaks at 0.7 on the same HumanEval/MBPP normalization settings used for final results, so it is tuned on the test benchmarks.
  • top-k for reranking context = 50
    Section 2.1 states the top-50 documents are used in reranking context; no sensitivity analysis is reported.
assumptions (4)
  • domain assumption Renaming identifiers and removing docstrings preserves code functionality
    Section 2.1 uses this to justify normalization as a controlled study; any accidental semantic change would confound the measured bias.
  • domain assumption The GT document is the unique relevant document for each query
    Used to compute Recall@k and rank; if other documents are semantically equivalent, the evaluation would mislabel relevant hits as negatives.
  • domain assumption HumanEval and MBPP solutions form a representative retrieval corpus
    Corpus construction is not detailed in the provided text; Appendix A.1 only names the datasets.
  • domain assumption ROUGE-1 is a valid measure of lexical overlap for retriever analysis
    Section 4.4 uses ROUGE to explain the mechanism; the relationship between ROUGE and retriever scores is not established.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SACL: Understanding and Combating Textual Bias in Code Retrieval with Semantic-Augmented Reranking and Localization." pith.science (2026). https://pith.science/paper/MKRP6J24

@misc{pith2026250620081,
  author       = {Pith},
  title        = {Pith review of: SACL: Understanding and Combating Textual Bias in Code Retrieval with Semantic-Augmented Reranking and Localization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/MKRP6J24}},
  note         = {Machine review of arXiv:2506.20081}
}
read the original abstract

Retrieval-Augmented Code Generation (RACG) is a critical technique for enhancing code generation by retrieving relevant information. In this work, we conduct an in-depth analysis of code retrieval by systematically masking specific features while preserving code functionality. Our discoveries include: (1) although trained on code, current retrievers heavily rely on surface-level textual features (e.g., docstrings, identifier names), and (2) they exhibit a strong bias towards well-documented code, even if the documentation is irrelevant. Based on our discoveries, we propose SACL, a framework that enriches textual information and reduces bias by augmenting code or structural knowledge with semantic information. Extensive experiments show that SACL substantially improves code retrieval (e.g., by 12.8% / 9.4% / 7.0% Recall@1 on HumanEval / MBPP / SWE-Bench-Lite), which also leads to better code generation performance (e.g., by 4.88% Pass@1 on HumanEval).

Figures

Figures reproduced from arXiv: 2506.20081 by the authors.

Figure 1
Figure 1. Summaries of our discoveries from the anal [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Impact of code normalization techniques on retrieval performance (Recall@1) across datasets with [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Flowchart illustrating our two main ap￾proaches. (left) Documents are retrieved based on query similarity, then augmented with generated descriptions. The final ranking score combines both code-query and description-query similarity scores to improve retrieval performance. (right) Repository structure is enhanced with descriptive summaries for each file (shown in green italics). This augmented structure significantl… view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Lexical overlap (ROUGE-1 scores) between [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Impact of normalization parameter α on Re￾call performance. The three plots show performance across different normalization approaches: Docstring (left), Function Name (middle), and Both - Functions and Variables (right). ate space-separated integers, the baseline mist…
Figure 6
Figure 6. Figure 6: Case Study 1 (HumanEval/15): The baseline incorrectly ranks a function that checks for linear sequences [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

21 extracted references · 2 canonical work pages

  1. [1]

    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 INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

  2. [2]

    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 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Miltiadis Allamanis, Earl T Barr, Premkumar Devanbu, and Charles Sutton. 2018. A survey of machine learning for big code and naturalness. ACM Computing Surveys (CSUR), 51(4):1--37

    work page 2018

  4. [4]

    Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie J

    Jacob Austin, Augustus Odena, Maxwell I. Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie J. Cai, Michael Terry, Quoc V. Le, and Charles Sutton. 2021. https://arxiv.org/abs/2108.07732 Program synthesis with large language models . CoRR, abs/2108.07732

    arXiv 2021

  5. [5]

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

    arXiv 2021

  6. [6]

    Sunhao Dai, Yuqi Zhou, Liang Pang, Weihao Liu, Xiaolin Hu, Yong Liu, Xiao Zhang, Gang Wang, and Jun Xu. 2024. https://doi.org/10.1145/3637528.3671882 Neural retrievers are biased towards llm-generated content . In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, KDD ’24, page 526–537. ACM

    arXiv 2024

  7. [7]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Y. Wu, Y. K. Li, Fuli Luo, Yingfei Xiong, and Wenfeng Liang. 2024. https://arxiv.org/abs/2401.14196 Deepseek-coder: When the large language model meets programming -- the rise of code intelligence . Preprint, arXiv:2401.14196

    arXiv 2024

  8. [8]

    Yucan Guo, Zixuan Li, Xiaolong Jin, Yantao Liu, Yutao Zeng, Wenxuan Liu, Xiang Li, Pan Yang, Long Bai, Jiafeng Guo, and Xueqi Cheng. 2023. https://arxiv.org/abs/2311.02962 Retrieval-augmented code generation for universal information extraction . Preprint, arXiv:2311.02962

    arXiv 2023

Show all 21 references
  1. [9]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, and 1 others. 2024. Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186

    2024 arXiv

  2. [10]

    Hamel Husain, Ho-Hsiang Wu, Tiferet Gazit, Miltiadis Allamanis, and Marc Brockschmidt. 2019. Codesearchnet challenge: Evaluating the state of semantic code search. arXiv preprint arXiv:1909.09436

    2019 arXiv

  3. [11]

    Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2023. Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770

    2023 arXiv

  4. [12]

    Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick SH Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020. Dense passage retrieval for open-domain question answering. In EMNLP (1), pages 6769--6781

    2020

  5. [13]

    Heiko Koziolek, Sten Gr \"u ner, Rhaban Hark, Virendra Ashiwal, Sofia Linsbauer, and Nafise Eskandani. 2024. Llm-based and retrieval-augmented control code generation. In Proceedings of the 1st International Workshop on Large Language Models for Code, pages 22--29

    2024

  6. [14]

    Shuai Lu, Nan Duan, Hojae Han, Daya Guo, Seung won Hwang, and Alexey Svyatkovskiy. 2022. https://arxiv.org/abs/2203.07722 Reacc: A retrieval-augmented code completion framework . Preprint, arXiv:2203.07722

    2022 arXiv

  7. [15]

    Yihao Qin, Shangwen Wang, Yiling Lou, Jinhao Dong, Kaixin Wang, Xiaoling Li, and Xiaoguang Mao. 2025. https://arxiv.org/abs/2403.16362 Agentfl: Scaling llm-based fault localization to project-level context . Preprint, arXiv:2403.16362

    2025 arXiv

  8. [16]

    Aivin V Solatorio. 2024. Gistembed: Guided in-sample selection of training negatives for text embedding fine-tuning. arXiv preprint arXiv:2402.16829

    2024 arXiv

  9. [17]

    Nandan Thakur, Nils Reimers, Andreas R \"u ckl \'e , Abhishek Srivastava, and Iryna Gurevych. 2021. Beir: A heterogenous benchmark for zero-shot evaluation of information retrieval models. arXiv preprint arXiv:2104.08663

    2021 arXiv

  10. [18]

    Xu, Yiqing Xie, Graham Neubig, and Daniel Fried

    Zora Zhiruo Wang, Akari Asai, Xinyan Velocity Yu, Frank F. Xu, Yiqing Xie, Graham Neubig, and Daniel Fried. 2025. https://arxiv.org/abs/2406.14497 Coderag-bench: Can retrieval augment code generation? Preprint, arXiv:2406.14497

    2025 arXiv

  11. [19]

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2024. https://arxiv.org/abs/2407.01489 Agentless: Demystifying llm-based software engineering agents . Preprint, arXiv:2407.01489

    2024 arXiv

  12. [20]

    Chuyang Xu, Zhongxin Liu, Xiaoxue Ren, Gehao Zhang, Ming Liang, and David Lo. 2025. https://doi.org/10.1109/TSE.2025.3553363 Flexfl: Flexible and effective fault localization with open-source large language models . IEEE Transactions on Software Engineering, 51(5):1455--1471

    2025

  13. [21]

    Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen. 2023. https://arxiv.org/abs/2303.12570 Repocoder: Repository-level code completion through iterative retrieval and generation . Preprint, arXiv:2303.12570

    2023 arXiv

Pith tools

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