Pith. sign in

REVIEW 3 major objections 6 minor 56 references

Code representation is a first-class design choice in agentic bug localization: role-aware summaries beat file-path baselines by up to 40% Hit@5 while using far fewer tokens than raw source.

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-14 07:25 UTC pith:LW3JLS4G

load-bearing objection Solid empirical bake-off showing representation choice actually moves file-level localization Hit rates and cost; role-aware summaries win the trade-off under their generator, with one clear unablated soft spot. the 3 major comments →

arxiv 2607.11046 v1 pith:LW3JLS4G submitted 2026-07-13 cs.SE

Retrieval-Oriented Code Representations in Agentic Bug Localization

Genevieve Caumartin , Tse-Hsun (Peter) Chen , Diego Elias Costa This is my paper
classification cs.SE
keywords information retrievalbug localizationlarge language modelscode representationrankingagentic software engineeringfile-level localizationrepresentation footprint
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.

This paper argues that repository-level bug localization for LLM agents is limited as much by how code is written for the retriever as by which retriever is used. Across Long Code Arena and SWE-bench Verified, the authors compare file paths, raw source, and three LLM-generated textual views under BM25, dense embeddings, and LLM retrieval, then LLM re-ranking, measuring both Hit@5/MAP@5 and representation footprint (token volume). Role-aware summaries of each file’s responsibilities consistently give the best cost–accuracy trade-off: they improve Hit@5 over paths by as much as 40% while shrinking the footprint by roughly 10–21× relative to raw source. Fusing complementary representations and re-ranking candidates with an LLM add further gains, and plugging the same ideas into an existing localization pipeline raises file-level Hit@6 to 94%. A reader who builds or deploys coding agents should care because wrong-file retrieval is an early, hard failure mode, and treating textual representation as a deliberate stage-wise design lever can raise hit rates without exploding context cost.

Core claim

File-level bug localization is representation-driven: which textual view of repository files is indexed and shown to retrievers and rankers changes both effectiveness and cost. Role-aware summaries outperform file-path baselines by up to 40% Hit@5 at a footprint 10.4–20.9× smaller than raw source; combining complementary representations and LLM post-retrieval ranking yield further gains of up to 31.9% and 42.0% Hit@5 in the reported settings; and integrating role-aware summaries plus ranking into a known pipeline reaches 94% Hit@6 (+4.7% over that baseline).

What carries the argument

Representation footprint—the token volume of the searchable index or LLM input for a given textual view of the repository—together with the five compared views (paths, raw source, role-aware summaries, detailed technical summaries, synthetic bug-report summaries). Footprint makes the accuracy–cost trade-off explicit and shows why compact role-aware summaries are the practical sweet spot for many stages.

Load-bearing premise

That role-aware summaries generated once by a single mid-size model with fixed prompts stay faithful, stable stand-ins for file meaning across repositories, languages, and later code changes.

What would settle it

Regenerate the role-aware summaries with a different model family or prompt set, re-run the same BM25, embedding, and LLM retrieval protocols on LCA and SWE-Verified, and check whether the reported Hit@5 gains over paths and the footprint advantage over raw source reverse or vanish.

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

If this is right

  • Agentic localization pipelines should choose representation by stage: inexpensive paths or raw source for first-stage retrieval, compact role-aware summaries when an LLM must compare many candidates under a token budget.
  • Rank fusion over complementary views can raise top-k coverage beyond any single representation.
  • Summary generation is a one-time or incremental preprocessing cost that can be amortized across many queries on the same repository.
  • Raw source remains strong for some lexical and embedding setups but is a poor default for single-prompt LLM ranking because it starves the model of candidates.
  • Representation belongs in the design space of retrieval architectures alongside the choice of sparse, dense, or LLM retriever.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If representation quality dominates, production systems will need continuous representation maintenance that regenerates summaries only for changed files, analogous to incremental indexing.
  • The same stage-wise representation trade-off likely extends to other repository-scale agent tasks—feature location, review, dependency analysis—where wrong-file retrieval is the bottleneck.
  • Synthetic bug-report expansions underperformed here; better conditioned, project-tuned expansion might still recover classic document-expansion gains for code.
  • Smaller open models may need hybrid lexical or structural cues even when larger models thrive on dense summaries, so representation should be co-tuned with model scale.

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

3 major / 6 minor

Summary. The paper frames file-level bug localization for agentic repair as a representation-driven retrieval problem. On Long Code Arena (150 tasks) and SWE-bench Verified (500 tasks) it compares five textual representations—file paths (STRUCT), raw source (RAW), role-aware summaries (ROLESUM), detailed technical summaries (TECSUM), and synthetic bug-report summaries (BUGSUM)—under BM25, four dense embedders, three Qwen2.5-Coder sizes (7B/14B/32B), reciprocal-rank fusion, and LLM post-retrieval ranking (k=20 candidates). Cost is quantified primarily via representation footprint (token volume). Headline results: ROLESUM improves Hit@5 over STRUCT by up to ~40% while using a footprint 10.4–20.9× smaller than RAW; fusion of complementary representations and LLM ranking add further gains (up to ~31.9% and ~42.0% Hit@5 in reported cells); an Agentless case study reaches 94% Hit@6 (+4.7%). The authors conclude that code representation should be treated as a first-class design choice guided by pipeline stage and cost–accuracy trade-offs.

Significance. If the reported trade-offs hold under broader conditions, the work supplies concrete, stage-aware guidance for agentic localization pipelines that currently default to paths or raw source. Strengths include breadth (lexical, dense, and LLM retrievers; two public long-context benchmarks; fusion and ranking stages), explicit footprint accounting, a practical Agentless transfer, and a full replication package (code, prompts, databases, results). These make the empirical bake-off reusable and falsifiable within the studied generator/prompt/setup. The main contribution is not a new retriever but evidence that representation choice materially changes both Hit@k/MAP@k and context cost—an under-studied lever in repository-scale agent design.

major comments (3)
  1. Section 3.2 and Threats to Validity: the central design recommendation—that ROLESUM is the best cost-effectiveness trade-off and therefore that representation should be a first-class choice—rests on summaries produced once by a single mid-size model (GPT-OSS 20B) under author-chosen block-structured prompts, with only “preliminary experimentation” used to retain three variants. Tables 2 and 5 (and the Agentless transfer) report the headline Hit@5/footprint lifts only for those particular summaries. There is no ablation of generator family (general vs code-specialized), temperature, or prompt wording, nor any inter-generator agreement or summary-quality metric. Because the paper itself states that “File summaries’ quality highly affects retrieval quality,” the relative ranking of ROLESUM vs STRUCT/RAW (and fusion/ranking gains built on ROLESUM) may reverse under a different generator. Thi
  2. Results tables (Tables 2–7) and metrics section: all Hit@5/MAP@5 comparisons are point estimates with no statistical significance tests, confidence intervals, or bootstrap/error bars, despite modest task counts (n=150 LCA, n=500 SWE) and known non-determinism of LLM retrieval/ranking even at temperature 0. Several “best” cells differ by only a few percentage points; without uncertainty quantification it is hard to judge whether the claimed superiority of ROLESUM (or of particular fusions) is stable. Adding at least paired tests or bootstrap CIs on the primary Hit@5 contrasts would strengthen the cost-effectiveness ranking.
  3. Section 5.3 / Table 5 and Section 6: LLM-based retrieval frequently returns very small candidate sets (e.g., a single file in 48/150 LCA and 309/500 SWE instances for the 32B model). The authors correctly avoid feeding these sets into the ranking study, but the same conservatism affects interpretation of Hit@5 for LLM retrievers and of fusion gains that mix LLM and traditional lists. The paper should quantify how often top-k is truncated and discuss whether Hit@k remains comparable across retriever families when effective k differs systematically.
minor comments (6)
  1. Abstract and takeaways repeatedly cite “up to 40% Hit@5” and “10.4 to 20.9× smaller”; these maxima are correct for selected cells but can be read as typical. A short qualifier (“in the best retriever–dataset cells”) would avoid over-generalization.
  2. Table 9 (indexing time) flags a CodeXEmbed outlier on TECSUM due to memory offloading; the main text should either exclude that cell from qualitative claims or re-run with adjusted batch/token limits so the table is not misleading.
  3. Section 3.5: MAP@5 and Hit@5 are standard, but the choice of k=5 (and Agentless Hit@6) is justified only briefly as a “developer inspection budget.” A one-sentence sensitivity note (e.g., Hit@10 trends) would help readers who use different cutoffs.
  4. Figure 6 caption and surrounding text: “Path / Sum / Raw / Bug” abbreviations are clear in context but should be expanded once in the caption for standalone readability.
  5. Related Work §2.2–2.3: the positioning against hierarchical pipelines (e.g., Agentless skeletons) and doc2query-style expansion is good; a short explicit contrast with cross-encoder summary localization (Han et al.) would further clarify novelty of the multi-retriever, multi-stage bake-off.
  6. Threats: dataset contamination is acknowledged as an upper bound; stating whether any decontamination or post-cutoff filtering was attempted (even if none) would complete the discussion.

Circularity Check

0 steps flagged

No circularity: empirical bake-off of representations on external ground-truth labels and standard IR metrics.

full rationale

The paper is a self-contained comparative evaluation of five textual code representations (STRUCT, RAW, ROLESUM, TECSUM, BUGSUM) for file-level bug localization. It measures MAP@5 and Hit@k against independently labeled buggy files from public benchmarks (LCA Bug Localization and SWE-bench Verified). Representation footprint is a descriptive token-volume statistic, not a fitted or predicted quantity. Fusion via reciprocal rank fusion and LLM post-retrieval ranking are applied after retrieval and scored on the same external labels. No equation or claim reduces a “prediction” to a fitted input by construction; no uniqueness theorem or load-bearing self-citation forces the ranking of representations. Self-references are confined to the replication package. The central design recommendation follows directly from observed effectiveness–cost trade-offs on held-out tasks, not from definitional circularity.

Axiom & Free-Parameter Ledger

5 free parameters · 4 axioms · 2 invented entities

The paper is empirical SE, not a formal derivation. Load-bearing choices are experimental design knobs (which summary prompts, k, context length, generator model) and standard IR/SE assumptions (file-level ground truth from patches, Hit@5 as developer budget). No new physical entities; ‘role-aware summary’ and ‘representation footprint’ are methodological constructs defined by the authors’ prompts and token counts.

free parameters (5)
  • Hit@k reporting cutoff (k=5; ranking over k=20; Agentless Hit@6)
    Primary effectiveness claims use author-chosen inspection budgets rather than a full precision-recall curve; different k can reorder representation rankings.
  • LLM context length fixed at 16k tokens
    Chosen after preliminary 8k/16k/32k tests; directly limits how many raw files fit in retrieval/ranking prompts and disadvantages RAW.
  • Number of synthetic bug reports per file (=5)
    Set after preliminary experiments; defines the BUGSUM representation entirely.
  • Summary-generation model and prompts (GPT-OSS 20B; three retained task blocks)
    Four prompt variants were tried; three kept. All summary quality—and thus ROLESUM/TECSUM/BUGSUM results—depends on this generator and wording.
  • BM25 hyperparameters (k1=0.9, b=0.4 defaults)
    Default Pyserini settings; not tuned per representation, which may favor or hurt some views.
axioms (4)
  • domain assumption File-level localization against patch-derived ground-truth files is a valid primary success criterion for agentic bug localization.
    Stated throughout methodology and metrics; ignores partial credit for near-miss files and method/line localization quality.
  • ad hoc to paper Token volume (representation footprint) is a sufficient primary cost proxy for comparing representations across retrievers.
    Section 3.3 explicitly focuses on context construction and footprint rather than full end-to-end latency, GPU-hours, or monetary retrieval cost for every setting.
  • domain assumption Standard IR metrics MAP@k and Hit@k adequately measure localization utility for developers/agents.
    Section 3.5; common in IRFL but abstracts away multi-file partial matches and downstream repair success except in the limited Agentless case study.
  • domain assumption Reciprocal rank fusion is an appropriate way to combine complementary representation rankings.
    Section 3.4 cites Cormack et al.; fusion gains depend on this choice among possible ensemble methods.
invented entities (2)
  • Role-aware summary (ROLESUM) representation no independent evidence
    purpose: Compact natural-language file view emphasizing responsibilities, classes/methods, and role for retrieval alignment with bug reports.
    Defined by author prompts rather than a standard corpus artifact; quality is generator-dependent. Not a physical entity, but a new operational construct central to the claim.
  • Representation footprint no independent evidence
    purpose: Quantify cost of a code view via token volume in the index/prompt.
    Author-defined cost measure used to argue cost-effectiveness; useful but not independently standardized outside this paper.

pith-pipeline@v1.1.0-grok45 · 31836 in / 3405 out tokens · 48969 ms · 2026-07-14T07:25:08.462416+00:00 · methodology

0 comments
read the original abstract

LLM-based agents are increasingly being used to support software development, yet their performance in repository-level tasks depends on retrieving the right code context. Existing studies have explored file-level localization using traditional information retrieval over file paths and raw source code. However, the role of textual code representations in retrieval and localization remains underexplored. We study file-level bug localization as a representation-driven retrieval problem. Across the Long Code Arena (LCA) and SWE-bench Verified (SWE) datasets, we compare five code representations: file paths, raw source code, and three LLM-generated textual representations. Our experiments include lexical, semantic, and LLM-based retrieval, followed by LLM-based post-retrieval ranking. We quantify the cost incurred by a representation through the representation footprint. We find that the choice of code representation affects both localization effectiveness and cost. Role-aware summaries outperform file-path representations by up to 40% Hit@5 while requiring a representation footprint 10.4 to 20.9x smaller than raw source code. Combining complementary representation results and ranking retrieved candidates with an LLM provides further gains of up to 31.9% and 42.0%, respectively. Overall, role-aware summaries provide the best cost-effectiveness trade-off, while raw source code offers effectiveness in some settings at a significantly higher cost. A case study with Agentless reveals the utility of our techniques within a well-known pipeline, reaching 94% Hit@6 on file localization (+4.7% against the baseline). Our findings suggest that code representation should be treated as a first-class design choice in agentic localization pipelines, guided by pipeline stage and cost-accuracy requirements.

Figures

Figures reproduced from arXiv: 2607.11046 by Diego Elias Costa, Genevieve Caumartin, Tse-Hsun (Peter) Chen.

Figure 1
Figure 1. Figure 1: An overview of our file-level retrieval process. [PITH_FULL_IMAGE:figures/full_fig_p006_1.png] view at source ↗
Figure 3
Figure 3. Figure 3: Summary generation. For summary generation, we select GPT-OSS 20B (OpenAI, 2025), a medium-sized general-purpose model. Given the scale of summary generation across 650 repos￾itories, we prioritize a model accessible via the Groq API2 for its high throughput and cost efficiency. While a code-specific model could be considered, our focus is on the quality of the 1 https://openai.com/index/introducing-swe-be… view at source ↗
Figure 2
Figure 2. Figure 2: Representations and Prompting Strategies (RQ1). [PITH_FULL_IMAGE:figures/full_fig_p008_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Sample Kotlin code snippet and derived bug reports. [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Sample Retrieval Prompt Template. “[REPRESENTATION]” is a placeholder for any [PITH_FULL_IMAGE:figures/full_fig_p015_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Sample Ranking Prompt Template. “[REPRESENTATION]” is a placeholder for any [PITH_FULL_IMAGE:figures/full_fig_p019_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Distribution of the number of files viewed in a single prompt per representation and [PITH_FULL_IMAGE:figures/full_fig_p021_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Overlap of bugs localized by different representations on LCA, showing the best [PITH_FULL_IMAGE:figures/full_fig_p025_7.png] view at source ↗
Figure 8
Figure 8. Figure 8: Overlap of bugs localized by different representations on SWE, showing the best [PITH_FULL_IMAGE:figures/full_fig_p025_8.png] view at source ↗
Figure 9
Figure 9. Figure 9: Qwen 32B - Representation contributions to localized bugs on LCA. Union of [PITH_FULL_IMAGE:figures/full_fig_p026_9.png] view at source ↗
Figure 10
Figure 10. Figure 10: Qwen 32B - Representation contributions to localized bugs on SWE. Union of [PITH_FULL_IMAGE:figures/full_fig_p026_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Example of a bug localized only by a role-aware summary using BM25. The issue [PITH_FULL_IMAGE:figures/full_fig_p027_11.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

56 extracted references · 6 canonical work pages

  1. [1]

    ACM Trans Inf Syst 20(4):357--389, doi:10.1145/582415.582416, ://doi.org/10.1145/582415.582416

    Amati G, Van Rijsbergen CJ (2002) Probabilistic models of information retrieval based on measuring the divergence from randomness. ACM Trans Inf Syst 20(4):357--389, doi:10.1145/582415.582416, ://doi.org/10.1145/582415.582416

    doi:10.1145/582415.582416 2002

  2. [2]

    ://www.anthropic.com/news/contextual-retrieval, accessed July 12, 2025

    Anthropic (2024) Introducting contextual retrieval. ://www.anthropic.com/news/contextual-retrieval, accessed July 12, 2025

    2024

  3. [3]

    ://arxiv.org/abs/2406.11612, arXiv:2406.11612 [cs]

    Bogomolov E, Eliseeva A, Galimzyanov T, Glukhov E, Shapkin A, Tigina M, Golubev Y, Kovrigin A, van Deursen A, Izadi M, Bryksin T (2024) Long code arena: a set of benchmarks for long-context code models. ://arxiv.org/abs/2406.11612, arXiv:2406.11612 [cs]

    Pith/arXiv arXiv 2024

  4. [4]

    ://huggingface.co/buckets/gencau/code-representations

    Caumartin G (2026 a ) Generated databases, datasets and results. ://huggingface.co/buckets/gencau/code-representations

    2026

  5. [5]

    ://github.com/gencau/code-representations

    Caumartin G (2026 b ) Replication package. ://github.com/gencau/code-representations

    2026

  6. [6]

    ://arxiv.org/abs/2502.15292, 2502.15292

    Chang J, Zhou X, Wang L, Lo D, Li B (2025) Bridging bug localization and issue fixing: A hierarchical localization framework leveraging large language models. ://arxiv.org/abs/2502.15292, 2502.15292

    Pith/arXiv arXiv 2025

  7. [7]

    Chen Z, Tang R, Deng G, Wu F, Wu J, Jiang Z, Prasanna V, Cohan A, Wang X (2025) L oc A gent: Graph-guided LLM agents for code localization. In: Che W, Nabende J, Shutova E, Pilehvar MT (eds) Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Association for Computational Linguistics, Vienna, Au...

    doi:10.18653/v1/2025.acl-long.426 2025

  8. [8]

    Cormack GV, Clarke CLA, Buettcher S (2009) Reciprocal rank fusion outperforms condorcet and individual rank learning methods. In: Proceedings of the 32nd International ACM SIGIR Conference on Research and Development in Information Retrieval, Association for Computing Machinery, New York, NY, USA, SIGIR '09, pp 758--759, doi:10.1145/1571941.1572114, ://do...

    doi:10.1145/1571941.1572114 2009

  9. [9]

    doi:10.1007/978-0-387-39940-9\_488, ://doi.org/10.1007/978-0-387-39940-9\_488

    Craswell N (2009) Mean Reciprocal Rank, Springer US, Boston, MA, pp 1703--1703. doi:10.1007/978-0-387-39940-9\_488, ://doi.org/10.1007/978-0-387-39940-9\_488

    doi:10.1007/978-0-387-39940-9 2009

  10. [10]

    ://arxiv.org/abs/1810.04805, 1810.04805

    Devlin J, Chang MW, Lee K, Toutanova K (2019) Bert: Pre-training of deep bidirectional transformers for language understanding. ://arxiv.org/abs/1810.04805, 1810.04805

    Pith/arXiv arXiv 2019

  11. [11]

    In: TREC, Citeseer, vol 2, pp 243--252

    Fox EA, Shaw JA (1994) Combination of multiple searches. In: TREC, Citeseer, vol 2, pp 243--252

    1994

  12. [12]

    In: Hiemstra D, Moens MF, Mothe J, Perego R, Potthast M, Sebastiani F (eds) Advances in Information Retrieval, Springer International Publishing, pp 146--160

    Gao L, Dai Z, Chen T, Fan Z, Van Durme B, Callan J (2021) Complement lexical retrieval model with semantic residual embeddings. In: Hiemstra D, Moens MF, Mothe J, Perego R, Potthast M, Sebastiani F (eds) Advances in Information Retrieval, Springer International Publishing, pp 146--160

    2021

  13. [13]

    Software Quality Journal 32(4):1515--1538, doi:10.1007/s11219-024-09693-1, ://doi.org/10.1007/s11219-024-09693-1

    Han J, Huang C, Liu J (2024) bjenet: a fast and accurate software bug localization method in natural language semantic space. Software Quality Journal 32(4):1515--1538, doi:10.1007/s11219-024-09693-1, ://doi.org/10.1007/s11219-024-09693-1

    work page doi:10.1007/s11219-024-09693-1 2024

  14. [14]

    In: 2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pp 500--510, doi:10.1109/SANER64311.2025.00053

    He P, Wang S, Chowdhury S, Chen TH (2025) Evaluating the effectiveness and efficiency of demonstration retrievers in rag for coding tasks. In: 2025 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), pp 500--510, doi:10.1109/SANER64311.2025.00053

    doi:10.1109/saner64311.2025.00053 2025

  15. [15]

    Journal of Systems and Software 222:112342, doi:10.1016/j.jss.2025.112342, ://www.sciencedirect.com/science/article/pii/S016412122500010X

    Hirsch T, Hofer B (2025) Best practices for evaluating irfl approaches. Journal of Systems and Software 222:112342, doi:10.1016/j.jss.2025.112342, ://www.sciencedirect.com/science/article/pii/S016412122500010X

    work page doi:10.1016/j.jss.2025.112342 2025

  16. [16]

    doi:10.48550/arXiv.2409.12186, ://arxiv.org/abs/2409.12186, arXiv:2409.12186 [cs]

    Hui B, Yang J, Cui Z, Yang J, Liu D, Zhang L, Liu T, Zhang J, Yu B, Lu K, Dang K, Fan Y, Zhang Y, Yang A, Men R, Huang F, Zheng B, Miao Y, Quan S, Feng Y, Ren X, Ren X, Zhou J, Lin J (2024) Qwen2.5-coder technical report. doi:10.48550/arXiv.2409.12186, ://arxiv.org/abs/2409.12186, arXiv:2409.12186 [cs]

    Pith/arXiv arXiv doi:10.48550/arxiv.2409.12186 2024

  17. [17]

    Huyen C (2024 a ) Evaluate AI Systems, O’Reilly, chap 4, pp 159--209

    2024

  18. [18]

    Huyen C (2024 b ) RAG and Agents, O’Reilly, chap 6, pp 253--306

    2024

  19. [19]

    ://arxiv.org/abs/2305.03653, 2305.03653

    Jagerman R, Zhuang H, Qin Z, Wang X, Bendersky M (2023) Query expansion by prompting large language models. ://arxiv.org/abs/2305.03653, 2305.03653

    Pith/arXiv arXiv 2023

  20. [20]

    doi:10.48550/arXiv.2408.11058, ://arxiv.org/abs/2408.11058, arXiv:2408.11058 [cs]

    Jain S, Dora A, Sam KS, Singh P (2024) Llm agents improve semantic code search. doi:10.48550/arXiv.2408.11058, ://arxiv.org/abs/2408.11058, arXiv:2408.11058 [cs]

    Pith/arXiv arXiv doi:10.48550/arxiv.2408.11058 2024

  21. [21]

    Jimenez CE, Yang J, Wettig A, Yao S, Pei K, Press O, Narasimhan KR (2024) SWE -bench: Can language models resolve real-world github issues? In: The Twelfth International Conference on Learning Representations, ://openreview.net/forum?id=VTF8yNQM66

    2024

  22. [22]

    In: 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC), pp 218--229, doi:10.1109/ICPC.2017.24

    Lam AN, Nguyen AT, Nguyen HA, Nguyen TN (2017) Bug localization with combination of deep learning and information retrieval. In: 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC), pp 218--229, doi:10.1109/ICPC.2017.24

    doi:10.1109/icpc.2017.24 2017

  23. [23]

    ://arxiv.org/abs/2507.15003, 2507.15003

    Li H, Zhang H, Hassan AE (2025) The rise of ai teammates in software engineering (se) 3.0: How autonomous coding agents are reshaping software engineering. ://arxiv.org/abs/2507.15003, 2507.15003

    Pith/arXiv arXiv 2025

  24. [24]

    arXiv preprint ://arxiv.org/abs/2308.13775

    Li J, Li Y, Li G, Hu X, Xia X, Jin Z (2023 a ) Editsum: A retrieve-and-edit framework for source code summarization. arXiv preprint ://arxiv.org/abs/2308.13775

    Pith/arXiv arXiv 2023

  25. [25]

    doi:10.48550/arXiv.2308.03281, ://arxiv.org/abs/2308.03281, arXiv:2308.03281 [cs]

    Li Z, Zhang X, Zhang Y, Long D, Xie P, Zhang M (2023 b ) Towards general text embeddings with multi-stage contrastive learning. doi:10.48550/arXiv.2308.03281, ://arxiv.org/abs/2308.03281, arXiv:2308.03281 [cs]

    Pith/arXiv arXiv doi:10.48550/arxiv.2308.03281 2023

  26. [26]

    In: Proceedings of the 44th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR 2021), pp 2356--2362

    Lin J, Ma X, Lin SC, Yang JH, Pradeep R, Nogueira R (2021) Pyserini : A Python toolkit for reproducible information retrieval research with sparse and dense representations. In: Proceedings of the 44th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR 2021), pp 2356--2362

    2021

  27. [27]

    In: Second Conference on Language Modeling, ://openreview.net/forum?id=z3lG70Azbg

    Liu Y, Meng R, Joty S, silvio savarese, Xiong C, Zhou Y, Yavuz S (2025) Code XE mbed: A generalist embedding model family for multilingual and multi-task code retrieval. In: Second Conference on Language Modeling, ://openreview.net/forum?id=z3lG70Azbg

    2025

  28. [28]

    In: Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp 6227--6240

    Lu S, Duan N, Han H, Guo D, Hwang Sw, Svyatkovskiy A (2022) Reacc: A retrieval-augmented code completion framework. In: Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp 6227--6240

    2022

  29. [29]

    Inf Softw Technol 52(9):972--990, doi:10.1016/j.infsof.2010.04.002, ://doi.org/10.1016/j.infsof.2010.04.002

    Lukins SK, Kraft NA, Etzkorn LH (2010) Bug localization using latent dirichlet allocation. Inf Softw Technol 52(9):972--990, doi:10.1016/j.infsof.2010.04.002, ://doi.org/10.1016/j.infsof.2010.04.002

    work page doi:10.1016/j.infsof.2010.04.002 2010

  30. [30]

    ://arxiv.org/abs/2406.01422, 2406.01422

    Ma Y, Yang Q, Cao R, Li B, Huang F, Li Y (2025) Alibaba lingmaagent: Improving automated issue resolution via comprehensive repository exploration. ://arxiv.org/abs/2406.01422, 2406.01422

    Pith/arXiv arXiv 2025

  31. [31]

    ://arxiv.org/abs/2502.16704, 2502.16704

    Makharev V, Ivanov V (2025) Code summarization beyond function level. ://arxiv.org/abs/2502.16704, 2502.16704

    Pith/arXiv arXiv 2025

  32. [32]

    ://doi.org/10.1145/3696630.3728533

    Mao Y, He J, Chen C (2025) From Prompts to Templates: A Systematic Prompt Template Analysis for Real-world LLMapps, Association for Computing Machinery, New York, NY, USA, pp 75--86. ://doi.org/10.1145/3696630.3728533

    doi:10.1145/3696630.3728533 2025

  33. [33]

    ://arxiv.org/abs/2510.21413, 2510.21413

    Mohsenimofidi S, Galster M, Treude C, Baltes S (2026) Context engineering for ai agents in open-source software. ://arxiv.org/abs/2510.21413, 2510.21413

    arXiv 2026

  34. [34]

    ://arxiv.org/abs/2410.12972, 2410.12972

    Murthy R, Venkateswaran P, Kumar P, Contractor D (2025) Kcif: Knowledge-conditioned instruction following. ://arxiv.org/abs/2410.12972, 2410.12972

    Pith/arXiv arXiv 2025

  35. [35]

    ://arxiv.org/abs/1904.08375, 1904.08375

    Nogueira R, Yang W, Lin J, Cho K (2019) Document expansion by query prediction. ://arxiv.org/abs/1904.08375, 1904.08375

    Pith/arXiv arXiv 2019

  36. [36]

    ://arxiv.org/abs/2508.10925, 2508.10925

    OpenAI (2025) gpt-oss-120b & gpt-oss-20b model card. ://arxiv.org/abs/2508.10925, 2508.10925

    Pith/arXiv arXiv 2025

  37. [37]

    doi:10.48550/arXiv.2409.13642, ://arxiv.org/abs/2409.13642, arXiv:2409.13642 [cs]

    Rafi MN, Kim DJ, Chen TH, Wang S (2024) Enhancing fault localization through ordered code analysis with llm agents and self-reflection. doi:10.48550/arXiv.2409.13642, ://arxiv.org/abs/2409.13642, arXiv:2409.13642 [cs]

    Pith/arXiv arXiv doi:10.48550/arxiv.2409.13642 2024

  38. [38]

    Rao S, Kak A (2011) Retrieval from software libraries for bug localization: a comparative study of generic and composite text models. In: Proceedings of the 8th Working Conference on Mining Software Repositories, Association for Computing Machinery, New York, NY, USA, MSR '11, pp 43--52, doi:10.1145/1985441.1985451, ://doi.org/10.1145/1985441.1985451

    doi:10.1145/1985441.1985451 2011

  39. [39]

    In: Proceedings of the 14th Information Retrieval Workshop, ://ceur-ws.org/Vol-3802/paper22.pdf

    Rizzo D, Raganato A, Viviani M (2024) Comparatively assessing large language models for query expansion in information retrieval via zero-shot and chain-of-thought prompting. In: Proceedings of the 14th Information Retrieval Workshop, ://ceur-ws.org/Vol-3802/paper22.pdf

    2024

  40. [40]

    Found Trends Inf Retr 3(4):333--389, doi:10.1561/1500000019, ://doi.org/10.1561/1500000019

    Robertson S, Zaragoza H (2009) The probabilistic relevance framework: Bm25 and beyond. Found Trends Inf Retr 3(4):333--389, doi:10.1561/1500000019, ://doi.org/10.1561/1500000019

    doi:10.1561/1500000019 2009

  41. [42]

    In: 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE), pp 345--355, doi:10.1109/ASE.2013.6693093

    Saha RK, Lease M, Khurshid S, Perry DE (2013 b ) Improving bug localization using structured information retrieval. In: 2013 28th IEEE/ACM International Conference on Automated Software Engineering (ASE), pp 345--355, doi:10.1109/ASE.2013.6693093

    doi:10.1109/ase.2013.6693093 2013

  42. [43]

    Wang L, Yang N, Wei F (2023) Query2doc: Query expansion with large language models. In: Bouamor H, Pino J, Bali K (eds) Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, Association for Computational Linguistics, Singapore, pp 9414--9423, doi:10.18653/v1/2023.emnlp-main.585, ://aclanthology.org/2023.emnlp-main.585/

    doi:10.18653/v1/2023.emnlp-main.585 2023

  43. [44]

    Wang S, Lo D (2014) Version history, similar report, and structure: putting them together for improved bug localization. In: Proceedings of the 22nd International Conference on Program Comprehension, Association for Computing Machinery, New York, NY, USA, ICPC 2014, pp 53--63, doi:10.1145/2597008.2597148, ://doi.org/10.1145/2597008.2597148

    doi:10.1145/2597008.2597148 2014

  44. [45]

    IEEE Transactions on Software Engineering 50(7):1852--1866, doi:10.1109/TSE.2024.3403042

    Wang S, Geng M, Lin B, Sun Z, Wen M, Liu Y, Li L, Bissyandé TF, Mao X (2024) Fusing code searchers. IEEE Transactions on Software Engineering 50(7):1852--1866, doi:10.1109/TSE.2024.3403042

    work page doi:10.1109/tse.2024.3403042 2024

  45. [46]

    ://arxiv.org/abs/2407.01489, 2407.01489

    Xia CS, Deng Y, Dunn S, Zhang L (2024) Agentless: Demystifying llm-based software engineering agents. ://arxiv.org/abs/2407.01489, 2407.01489

    Pith/arXiv arXiv 2024

  46. [47]

    2309.07597

    Xiao S, Liu Z, Zhang P, Muennighoff N (2023) C-pack: Packaged resources to advance general chinese embedding. 2309.07597

    Pith/arXiv arXiv 2023

  47. [48]

    ://arxiv.org/abs/2501.05040, 2501.05040

    Xie C, Li B, Gao C, Du H, Lam W, Zou D, Chen K (2025) Swe-fixer: Training open-source llms for effective and efficient github issue resolution. ://arxiv.org/abs/2501.05040, 2501.05040

    Pith/arXiv arXiv 2025

  48. [49]

    IEEE Trans Softw Eng 51(5):1455–1471, doi:10.1109/TSE.2025.3553363, ://doi.org/10.1109/TSE.2025.3553363

    Xu C, Liu Z, Ren X, Zhang G, Liang M, Lo D (2025) Flexfl: Flexible and effective fault localization with open-source large language models. IEEE Trans Softw Eng 51(5):1455–1471, doi:10.1109/TSE.2025.3553363, ://doi.org/10.1109/TSE.2025.3553363

    doi:10.1109/tse.2025.3553363 2025

  49. [50]

    In: The Twelfth International Conference on Learning Representations, ://openreview.net/forum?id=mlJLVigNHp

    Xu F, Shi W, Choi E (2024) RECOMP : Improving retrieval-augmented LM s with context compression and selective augmentation. In: The Twelfth International Conference on Learning Representations, ://openreview.net/forum?id=mlJLVigNHp

    2024

  50. [51]

    Advances in Neural Information Processing Systems 37:50528--50652

    Yang J, Jimenez CE, Wettig A, Lieret K, Yao S, Narasimhan K, Press O (2024) Swe-agent: Agent-computer interfaces enable automated software engineering. Advances in Neural Information Processing Systems 37:50528--50652

    2024

  51. [52]

    ACM Trans Softw Eng Methodol doi:10.1145/3799693, ://doi.org/10.1145/3799693, just Accepted

    Zhang Q, Fang C, Xie Y, Ma Y, Sun W, Yang Y, Chen Z (2026) A systematic literature review on large language models for automated program repair. ACM Trans Softw Eng Methodol doi:10.1145/3799693, ://doi.org/10.1145/3799693, just Accepted

    doi:10.1145/3799693 2026

  52. [53]

    Zhang Y, Ruan H, Fan Z, Roychoudhury A (2024) Autocoderover: Autonomous program improvement. In: Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, Association for Computing Machinery, New York, NY, USA, ISSTA 2024, pp 1592--1604, doi:10.1145/3650212.3680384, ://doi.org/10.1145/3650212.3680384

    doi:10.1145/3650212.3680384 2024

  53. [54]

    arXiv preprint arXiv:250605176

    Zhang Y, Li M, Long D, Zhang X, Lin H, Yang B, Xie P, Yang A, Liu D, Lin J, Huang F, Zhou J (2025) Qwen3 embedding: Advancing text embedding and reranking through foundation models. arXiv preprint arXiv:250605176

    2025

  54. [55]

    Zheng Z, Hui K, He B, Han X, Sun L, Yates A (2020) BERT-QE : C ontextualized Q uery E xpansion for D ocument R e-ranking. In: Cohn T, He Y, Liu Y (eds) Findings of the Association for Computational Linguistics: EMNLP 2020, Association for Computational Linguistics, Online, pp 4718--4728, doi:10.18653/v1/2020.findings-emnlp.424, ://aclanthology.org/2020.fi...

    work page doi:10.18653/v1/2020.findings-emnlp.424 2020

  55. [56]

    In: 2012 34th International Conference on Software Engineering (ICSE), pp 14--24, doi:10.1109/ICSE.2012.6227210

    Zhou J, Zhang H, Lo D (2012) Where should the bugs be fixed? more accurate information retrieval-based bug localization based on bug reports. In: 2012 34th International Conference on Software Engineering (ICSE), pp 14--24, doi:10.1109/ICSE.2012.6227210

    doi:10.1109/icse.2012.6227210 2012

  56. [57]

    Know-Based Syst 248(C), doi:10.1016/j.knosys.2022.108741, ://doi.org/10.1016/j.knosys.2022.108741

    Zhu Z, Tong H, Wang Y, Li Y (2022) Enhancing bug localization with bug report decomposition and code hierarchical network. Know-Based Syst 248(C), doi:10.1016/j.knosys.2022.108741, ://doi.org/10.1016/j.knosys.2022.108741

    work page doi:10.1016/j.knosys.2022.108741 2022