Pith. sign in

REVIEW 1 major objections 1 minor 52 references

Procedural similarity lifts repo-level code generation to 41% Pass@1

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 · glm-5.2

2026-07-10 02:55 UTC pith:DHFG5UMC

load-bearing objection New retrieval signal for repo-level code gen; ablation doesn't isolate it cleanly the 1 major comments →

arxiv 2607.08691 v1 pith:DHFG5UMC submitted 2026-07-09 cs.SE cs.AIcs.IR

ProjAgent: Procedural Similarity Retrieval for Repository-Level Code Generation

QiHong Chen , Aaron Imani , Iftekhar Ahmed This is my paper
classification cs.SE cs.AIcs.IR
keywords repository-level code generationprocedural similarityreasoning-subspace projectionretrieval-augmented generationhidden-state representationsagentic retrievalstatic-analysis feedbackcode generation
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.

The paper claims that repository-level code generation can be substantially improved by retrieving not just lexically or semantically similar code, but code that implements the same computational procedure—what the authors call procedurally similar context. The central object is the reasoning-subspace projection: a technique that extracts the internal reasoning behavior of an LLM from its hidden states, after removing a dominant shared direction (anisotropy) via PCA debiasing. The authors argue that cosine similarity between these debiased projections captures whether two code steps follow the same logical procedure (e.g., input validation, state transformation) even when they share no surface-level lexical or semantic overlap and reside in entirely different modules. ProjAgent, the system built around this idea, decomposes a target function into logical steps, retrieves procedurally similar context steps from across the repository using projection similarity plus an agentic search and LLM verification pipeline, combines them with conventional semantic retrieval of APIs and symbols, and then generates code with a conservative static-analysis feedback loop. On the REPOCOD benchmark (980 problems across 11 Python repositories), ProjAgent achieves 41.14% Pass@1, outperforming the prior best retrieval-augmented baseline (SpecAgent at 34.52%) by 6.62 percentage points. The ablation shows that removing procedural retrieval drops performance to 25.76%, a larger degradation than removing semantic retrieval (32.29%), suggesting procedural context contributes the more irreplaceable signal. The authors position projection similarity not as a standalone classifier but as a candidate-generation mechanism: it reliably filters out dissimilar steps (leftover-group precision above 97.9%) but produces many false positives in the promoted group (precision 3.6–6.7%), which a subsequent LLM verification step must clean up.

Core claim

The paper introduces procedural similarity—measured via debiased LLM hidden-state reasoning-subspace projections—as a new retrieval dimension for repository-level code generation, and shows that combining it with conventional semantic retrieval yields a 6.62-point Pass@1 improvement over the strongest existing baseline on REPOCOD. The key empirical finding is that projection similarity alone is a weak classifier (promoted-group precision 3.6–6.7%) but a strong negative filter (leftover-group precision ≥97.9%), making it effective as a candidate-generation step paired with LLM verification rather than as a standalone similarity measure.

What carries the argument

The central mechanism is the reasoning-subspace projection. The authors take the unembedding-layer parameter matrix of an LLM, apply singular value decomposition to separate a semantic subspace (dominant singular vectors) from a reasoning subspace (remaining vectors), project last-layer hidden states of response tokens onto the reasoning subspace, and then debias the resulting projections by removing their shared mean and first principal component (to counter anisotropy). Cosine similarity between these debiased projections serves as a procedural-similarity score between code steps. This is embedded in an agentic pipeline that decomposes functions into logical steps, retrieves and verifies候选

Load-bearing premise

The paper assumes that debiased LLM hidden-state reasoning-subspace projections capture procedural similarity between code steps in a way that is meaningfully more discriminative than semantic similarity. The RQ2 results show this is only weakly true: projection similarity achieves 3.6–6.7% precision in identifying procedurally similar steps, meaning it generates roughly 15–28 false positives for every true positive. The system's effectiveness therefore depends on a separate,

What would settle it

If the LLM-based verification step that filters projection-similarity candidates were removed or degraded, the procedural retrieval signal would collapse into noise, since projection similarity alone has precision below 7%. A direct test would be to replace the LLM verifier with a random selector from the promoted group and measure whether Pass@1 drops to the level of the no-procedural-retrieval ablation (25.76%). If it does not drop substantially, the contribution is the verifier, not the projection.

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

If this is right

  • If procedural similarity is a genuine and complementary retrieval signal, then repository-level code generation systems that currently rely solely on lexical, semantic, or structural retrieval are systematically missing a class of useful context—functions that teach the model how to implement a step rather than what APIs to call.
  • The finding that projection similarity is a strong negative filter but weak positive classifier suggests a two-stage retrieval architecture (cheap projection-based candidate generation + expensive verification) may be a general design pattern for behavior-aware retrieval beyond code generation.
  • The observation that only 35.1% of target steps have a genuine procedurally similar context in the repository sets an upper bound on how much procedural retrieval alone can contribute, motivating hybrid approaches that gracefully degrade when no procedural match exists.
  • The gap between budget-constrained agentic search (21.16%) and full offline search (25.12%) on Astropy suggests that repository exploration efficiency, not representation quality, is the primary bottleneck for further gains.

Where Pith is reading between the lines

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

  • If reasoning-subspace projections capture procedural similarity for code steps, the same technique might transfer to other software-engineering tasks where behavioral rather than textual similarity matters—e.g., test generation, bug detection, or clone detection—though the paper does not test these.
  • The dependence on LLM verification to filter projection-similarity false positives creates a circularity risk: the same model family that generates code also judges procedural similarity, so systematic blind spots in the model's understanding of procedures would propagate through both stages.
  • The energy threshold (0.98) and projection-similarity threshold (0.75) were calibrated on a single repository (Astropy); whether these transfer to repositories with different domain vocabularies or coding conventions is untested and could affect retrieval quality.

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

1 major / 1 minor

Summary. The paper introduces ProjAgent, a repository-level code generation system that retrieves procedurally similar context using LLM hidden-state reasoning-subspace projections, combined with conventional semantic retrieval and a static-analysis feedback loop. The core idea is that functions implementing similar computational procedures (e.g., input validation, state transformation) can provide useful generation context even when they share little lexical or semantic overlap. ProjAgent decomposes target and context functions into logical steps, computes projections of those steps onto a reasoning subspace derived via SVD of the unembedding layer, and uses an agentic workflow to find, expand, and verify procedurally similar context. Evaluated on REPOCOD with Qwen2.5-Coder-14B-Instruct, ProjAgent achieves 41.14% Pass@1, outperforming SpecAgent (34.52%) and standard retrieval baselines. The paper includes an ablation study (RQ3) and a projection-effectiveness analysis (RQ2).

Significance. The paper's central contribution—procedural similarity as a retrieval dimension—is a genuinely novel angle for repository-level code generation, and the idea of using reasoning-subspace projections to capture implementation behavior beyond surface similarity is creative. The evaluation on REPOCOD with appropriate baselines and a single backbone model is well-structured. The RQ2 analysis honestly reports that projection similarity alone has low precision, which is commendable transparency. However, the significance is tempered by the fact that the core procedural signal (projection similarity) is not isolated from the agentic workflow and LLM verification that operationalize it, making it difficult to attribute the performance gains specifically to the proposed projection-based mechanism.

major comments (1)
  1. §6, Table 4 (RQ3 ablation): The 'w/o procedural' ablation removes the entire procedural pipeline—projection similarity, agentic seed finding, seed expansion, LLM verification, and plan confirmation—and attributes the 15.38-point drop to 'procedural retrieval.' However, this does not isolate the contribution of the projection-based procedural similarity signal from the agentic search and LLM verification components that surround it. The paper itself concludes (RQ2, Table 3) that projection similarity is 'most effective as a candidate generation mechanism rather than a standalone procedural similarity classifier,' with precision of only 3.6%–6.7% in the promoted group. This means the real discriminative work is done by the LLM verification step (§4.2), not the projection signal. An additional ablation that isolates the projection signal—for example, replacing procedural retrieval with ag+e
minor comments (1)
  1. placeholder

Circularity Check

0 steps flagged

No significant circularity: central claim tested against external benchmark; projection technique adapted from prior work with independent validation

full rationale

The paper's central claim—that procedural similarity improves repository-level code generation—is evaluated against the external REPOCOD benchmark with externally provided test cases, yielding 41.14% Pass@1. The reasoning-subspace projection technique is adapted from Hu et al. 2025 (HARP), a distinct prior work by different authors, and is not presented as a novel derivation requiring self-citation. The paper does not fit a parameter to data and then 'predict' a closely related quantity. The projection similarity threshold (0.75) and PCA debiasing parameters are empirically calibrated on a small sample, but the downstream code-generation results are independent measurements on held-out tasks. The RQ2 evaluation uses human-validated labels (κ=0.86 inter-rater, κ=0.82 with Claude) as ground truth, not the system's own outputs. The ablation in RQ3 removes entire pipeline components rather than isolating individual signals, which is a correctness/conflation concern (the skeptic's point about conflating projection similarity with agentic search and LLM verification is valid as an experimental design issue), but this is not circularity—it does not reduce the claimed result to its inputs by construction. No step in the derivation chain is self-definitional, no prediction is forced by a fit, and no load-bearing argument depends on a self-citation chain. The paper is self-contained against external benchmarks.

Axiom & Free-Parameter Ledger

15 free parameters · 6 axioms · 3 invented entities

The paper introduces one core invented entity (procedural similarity as a retrieval signal) and one technical entity (reasoning-subspace projection for procedural steps). Both have independent empirical evidence through the REPOCOD evaluation and human-annotated validation. The system has 15 free parameters, many empirically calibrated on small samples (e.g., five target steps for the 0.75 threshold), which introduces overfitting risk. The key axioms are adopted from prior work (HARP) and domain assumptions about LLM hidden states, with one ad-hoc assumption that LLM-based verification reliably filters procedural similarity.

free parameters (15)
  • energy_threshold = 0.98
    Increased from 0.95 (Hu et al.) to 0.98 to yield approximately 5% of hidden state dimension as reasoning subspace for Qwen2.5-Coder-14B-Instruct. Empirically tested.
  • projection_similarity_threshold (initial seeds) = 0.75
    Threshold for discarding candidate steps during initial seed finding. Calibrated on five randomly selected target steps from Astropy.
  • projection_similarity_threshold (seed expansion) = 0.65
    Threshold for retaining context steps during seed expansion. Determined empirically.
  • seed_agreement_count (k) = 2
    Minimum number of seeds that must agree (similarity > threshold) for a candidate to be retained in seed expansion. Determined empirically.
  • ROUGE-L threshold (step validation) = 0.7
    Threshold for accepting a step description as valid based on ROUGE-L score with docstring. Following prior work.
  • embedding similarity threshold (snippet validation) = 0.75
    Cosine similarity threshold between step description and code snippet embeddings for snippet validity. Following prior work.
  • mu stability threshold (tau_mu) = 1e-3
    Relative change threshold for mean stability in incremental stabilization algorithm.
  • PC1 stability threshold (tau_PC1) = 0.99
    Absolute cosine similarity threshold for PC1 stability in incremental stabilization algorithm.
  • max iterations (agentic search) = 5
    Maximum number of iterations for procedural context retrieval workflow.
  • max iterations (feedback loop) = 10
    Maximum number of iterations for static-analysis feedback loop.
  • top files selected = 20
    Number of top-ranked files selected for offline preprocessing.
  • top candidates retained = 20
    Number of top candidates retained after projection similarity filtering in initial seed finding.
  • top context steps verified = 30
    Number of top context steps in expand context steps that undergo LLM-based verification.
  • top semantic symbols = 20
    Number of top-ranked symbols selected as semantic contexts per target step.
  • BM25/dense weight = 0.5
    Weight assigned to BM25 and dense scores in semantic retrieval scoring formula (v = 0.5*BM25 + 0.5*dense).
axioms (6)
  • domain assumption LLM hidden states can be decomposed into a semantic subspace and a reasoning subspace via SVD on the unembedding layer.
    Section 3, adopted from Hu et al. 2025 (HARP). The paper assumes this decomposition is valid for code-generation LLMs and that the reasoning subspace captures procedural logic.
  • domain assumption The reasoning subspace occupies approximately 5% of the hidden state dimension.
    Section 3, from Hu et al. 2025. The energy threshold is adjusted to achieve this 5% ratio for Qwen2.5-Coder-14B-Instruct.
  • domain assumption Functions within the same file often provide useful contextual information for code generation.
    Section 4.1, used to justify the file selection ranking strategy. Cites prior work (DevEval, Li et al. 2024).
  • ad hoc to paper LLM-based verification can reliably determine whether a context step is procedurally similar to a target step.
    Sections 4.2 (Initial Seed Finding, Verification). The system relies on LLM judgment to filter false positives from projection similarity, but the accuracy of this verification is not independently validated.
  • domain assumption Python's dynamic typing prevents complete static resolution, so conservative feedback is sufficient.
    Section 4.4, justifies the conservative design of the static-analysis feedback loop.
  • domain assumption Greedy decoding (temperature 0) controls LLM non-determinism adequately for evaluation.
    Section 5.1, used for all evaluations.
invented entities (3)
  • Procedural similarity (as a retrieval signal) independent evidence
    purpose: A new retrieval dimension capturing the extent to which two functions implement similar computational procedures regardless of naming or domain vocabulary.
    The paper provides empirical evidence (RQ1, RQ3 ablation) that adding this signal improves code generation. The concept is validated against external benchmarks and human annotations.
  • Reasoning-subspace projection for procedural steps independent evidence
    purpose: A representation of a code step's computational logic, obtained by projecting LLM hidden states onto the reasoning subspace and applying PCA debiasing.
    RQ2 evaluates this representation's ability to distinguish procedurally similar from dissimilar steps, showing high leftover-group precision (≥97.9%) but low promoted-group precision (3.6%–6.7%). The representation has falsifiable properties tested against human labels.
  • Incremental stabilization algorithm for mu and PC1 no independent evidence
    purpose: Computes stable mean and first principal component for debiasing projections across a repository.
    Algorithm 1 is described but its stability properties are not formally proven; it relies on empirical convergence thresholds.

pith-pipeline@v1.1.0-glm · 21102 in / 3790 out tokens · 231767 ms · 2026-07-10T02:55:58.831666+00:00 · methodology

0 comments
read the original abstract

Repository-level code generation requires implementing target functions while accounting for complex cross-file dependencies and project-specific conventions. Existing retrieval methods predominantly rely on lexical, structural, or semantic similarity, often overlooking repository functions that implement similar procedural logic despite differing in identifiers or application domains. We propose ProjAgent, a repository-level code generation system that introduces procedural similarity as an explicit retrieval signal. ProjAgent decomposes the target function into intermediate reasoning steps and employs an agentic workflow to retrieve repository functions that exhibit similar procedural behavior at each step. The retrieved procedural context is integrated with conventional semantic retrieval to construct a richer repository context for code generation. ProjAgent further incorporates a conservative static-analysis feedback loop that iteratively repairs generated code using compiler and static-analysis feedback. Evaluated on REPOCOD, ProjAgent achieves 41.14% Pass@1, outperforming existing retrieval-based baselines. These results demonstrate that procedural similarity is an effective and previously unexplored retrieval dimension for repository-level code generation.

Figures

Figures reproduced from arXiv: 2607.08691 by Aaron Imani, Iftekhar Ahmed, Qihong Chen.

Figure 1
Figure 1. Figure 1: Overview of the ProjAgent pipeline. Stage 1 preprocesses the repository. Stage 2a and Stage 2b retrieve [PITH_FULL_IMAGE:figures/full_fig_p006_1.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

52 extracted references · 52 canonical work pages · 11 internal anchors

  1. [1]

    Abubakar Ahmad Aliero, Sulaimon Adebayo Bashir, Hamzat Olanrewaju Aliyu, Amina Gogo Tafida, Umar Kangiwa Bashar, and Muhammad Dankolo Nasiru. 2023. Systematic review on text normalization techniques and its approach to non-standard words. (2023)

    work page 2023

  2. [2]

    Anthropic. 2025. Claude Sonnet 4.6. Accessed: 2025. https://www.anthropic.com/claude

    work page 2025

  3. [3]

    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 (2021)

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  4. [4]

    Nghi DQ Bui. 2026. Building effective ai coding agents for the terminal: Scaffolding, harness, context engineering, and lessons learned.arXiv preprint arXiv:2603.05344(2026)

    work page arXiv 2026

  5. [5]

    Junhao Chen, Jingxuan Zhang, Jian He, Yixuan Tang, and Weiqin Zou. 2026. Bridging the programming language gap: Constructing a multilingual shared semantic space through AST unification and graph matching.arXiv preprint arXiv:2605.07788(2026)

    work page internal anchor Pith review Pith/arXiv arXiv 2026

  6. [6]

    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)

    work page internal anchor Pith review Pith/arXiv arXiv 2021

  7. [7]

    Xinyun Chen, Maxwell Lin, Nathanael Schärli, and Denny Zhou. 2024. Teaching large language models to self-debug. InInternational Conference on Learning Representations, Vol. 2024. 8746–8825

    work page 2024

  8. [8]

    Wei Cheng, Yuhan Wu, and Wei Hu. 2024. Dataflow-guided retrieval augmentation for repository-level code completion. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 7957–7977

    work page 2024

  9. [9]

    Kawin Ethayarajh. 2019. How contextual are contextualized word representations? Comparing the geometry of BERT, ELMo, and GPT-2 embeddings. InProceedings of the 2019 conference on empirical methods in natural language processing and the 9th international joint conference on natural language processing (EMNLP-IJCNLP). 55–65

    work page 2019

  10. [10]

    Xiang Gao and Kamalika Das. 2024. Customizing language model responses with contrastive in-context learning. In Proceedings of the aaai conference on artificial intelligence, Vol. 38. 18039–18046

    work page 2024

  11. [11]

    2013.Matrix computations

    Gene H Golub and Charles F Van Loan. 2013.Matrix computations. JHU press

    work page 2013

  12. [12]

    Wenchao Gu, Juntao Chen, Yanlin Wang, Tianyue Jiang, Xingzhe Li, Mingwei Liu, Xilin Liu, Yuchi Ma, and Zibin Zheng. 2025. What to retrieve for effective retrieval-augmented code generation? an empirical study and beyond. arXiv preprint arXiv:2503.20589(2025)

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  13. [13]

    Chao Hu, Wenhao Zeng, Yuling Shi, Beijun Shen, and Xiaodong Gu. 2026. In Line with Context: Repository-Level Code Generation via Context Inlining.Proc. ACM Softw. Eng.3, FSE, Article FSE066 (June 2026), 23 pages. doi:10.1145/3797094

    work page doi:10.1145/3797094 2026

  14. [14]

    Junjie Hu, Gang Tu, ShengYu Cheng, Jinxin Li, Jinting Wang, Rui Chen, Zhilong Zhou, and Dongbo Shan. 2025. HARP: Hallucination Detection via Reasoning Subspace Projection.arXiv preprint arXiv:2509.11536(2025)

    work page arXiv 2025

  15. [15]

    Yiran Hu, Nan Jiang, Shanchao Liang, Yi Wu, and Lin Tan. 2025. TENET: Leveraging Tests Beyond Validation for Code Generation.arXiv preprint arXiv:2509.24148(2025)

    work page arXiv 2025

  16. [16]

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

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  17. [17]

    Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. 2024. Swe- bench: Can language models resolve real-world github issues?. InInternational Conference on Learning Representations, 18 Chen et al. Vol. 2024. 54107–54157

    work page 2024

  18. [18]

    Minsuh Joo and Hyunsoo Cho. 2025. Cleanse: Uncertainty Estimation Approach Using Clustering-based Semantic Consistency in LLMs. InProceedings of the Fourth Workshop on Generation, Evaluation and Metrics (GEM 2). 291–301

    work page 2025

  19. [19]

    D Kosenko and D Zharikova. 2024. KRGP: Knowledge-Based Response Generation with Persona.Journal of Mathe- matical Sciences285, 1 (2024), 49–59

    work page 2024

  20. [20]

    J Richard Landis and Gary G Koch. 1977. The measurement of observer agreement for categorical data.biometrics (1977), 159–174

    work page 1977

  21. [21]

    Bui, and Bach Le

    Minh Le-Anh, Huyen Nguyen, An Khanh Tran, Nam Le Hai, Linh Ngo Van, Nghi D.Q. Bui, and Bach Le. 2026. Do Not Treat Code as Natural Language: Implications for Repository-Level Code Generation and Beyond.Proc. ACM Softw. Eng.3, FSE, Article FSE017 (June 2026), 24 pages. doi:10.1145/3797144

    work page doi:10.1145/3797144 2026

  22. [22]

    Nam Le Hai, Dung Manh Nguyen, and Nghi DQ Bui. 2024. Repoexec: Evaluate code generation with a repository-level executable benchmark.arXiv preprint arXiv:2406.11927(2024)

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  23. [23]

    Gregor Leusch, Nicola Ueffing, David Vilar, and Hermann Ney. 2005. Preprocessing and normalization for automatic evaluation of machine translation. InProceedings of the ACL Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization. 17–24

    work page 2005

  24. [24]

    Jia Li, Ge Li, Yunfei Zhao, Yongmin Li, Huanyu Liu, Hao Zhu, Lecheng Wang, Kaibo Liu, Zheng Fang, Lanshen Wang, et al. 2024. Deveval: A manually-annotated code generation benchmark aligned with real-world code repositories. In Findings of the Association for Computational Linguistics: ACL 2024. 3603–3614

    work page 2024

  25. [25]

    Kenneth Li, Aspen K Hopkins, David Bau, Fernanda Viégas, Hanspeter Pfister, and Martin Wattenberg. 2023. Emergent World Representations: Exploring a Sequence Model Trained on a Synthetic Task. InThe Eleventh International Conference on Learning Representations. https://openreview.net/forum?id=DeG07_TcZvT

    work page 2023

  26. [26]

    Shanchao Liang, Nan Jiang, Yiran Hu, and Lin Tan. 2025. Can language models replace programmers for coding? REPOCOD says ‘not yet’. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 24698–24717

    work page 2025

  27. [27]

    Chin-Yew Lin. 2004. Rouge: A package for automatic evaluation of summaries. InText summarization branches out. 74–81

    work page 2004

  28. [28]

    Wei Liu, Ailun Yu, Daoguang Zan, Bo Shen, Wei Zhang, Haiyan Zhao, Zhi Jin, and Qianxiang Wang. 2024. Graph- Coder: Enhancing Repository-Level Code Completion via Coarse-to-fine Retrieval Based on Code Context Graph. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering(Sacramento, CA, USA) (ASE ’24). Association fo...

    work page doi:10.1145/3691620.3695054 2024

  29. [29]

    George Ma, Anurag Koul, Qi Chen, Yawen Wu, Sachit Kuhar, Yu Yu, Aritra Sengupta, Varun Kumar, and Murali Krishna Ramanathan. 2026. SpecAgent: A Speculative Retrieval and Forecasting Agent for Code Completion. InProceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Maria Liakata, Viviane P. Moreira...

    work page doi:10.18653/v1/2026.acl-long.786 2026

  30. [30]

    MemGPT: Towards LLMs as Operating Systems

    Charles Packer, Sarah Wooders, Kevin Lin, Vivian Fang, Shishir G. Patil, Ion Stoica, and Joseph E. Gonzalez. 2024. MemGPT: Towards LLMs as Operating Systems. arXiv:2310.08560

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  31. [31]

    Zhiyuan Pan, Xing Hu, Xin Xia, and Xiaohu Yang. 2024. Enhancing repository-level code generation with integrated contextual information.arXiv e-prints(2024), arXiv–2406

    work page 2024

  32. [32]

    Karl Pearson. 1901. LIII. On lines and planes of closest fit to systems of points in space.The London, Edinburgh, and Dublin philosophical magazine and journal of science2, 11 (1901), 559–572

    work page 1901

  33. [33]

    Huy N Phan, Hoang N Phan, Tien N Nguyen, and Nghi DQ Bui. 2025. Repohyper: Search-expand-refine on semantic graphs for repository-level code completion. In2025 IEEE/ACM Second International Conference on AI Foundation Models and Software Engineering (Forge). IEEE, 14–25

    work page 2025

  34. [34]

    Python Software Foundation. 2025. ast — Abstract Syntax Trees. Accessed: 2025. https://docs.python.org/3/library/ ast.html

    work page 2025

  35. [35]

    Nils Reimers and Iryna Gurevych. 2019. Sentence-bert: Sentence embeddings using siamese bert-networks. In Proceedings of the 2019 conference on empirical methods in natural language processing and the 9th international joint conference on natural language processing (EMNLP-IJCNLP). 3982–3992

    work page 2019

  36. [36]

    2009.The probabilistic relevance framework: BM25 and beyond

    Stephen Robertson and Hugo Zaragoza. 2009.The probabilistic relevance framework: BM25 and beyond. Vol. 4. Now Publishers Inc

    work page 2009

  37. [37]

    Anshul Shah, Anya Chernova, Elena Tomson, Leo Porter, William G Griswold, and Adalbert Gerald Soosai Raj. 2025. Students’ Use of GitHub Copilot for Working with Large Code Bases. InProceedings of the 56th ACM Technical Symposium on Computer Science Education V. 1. 1050–1056

    work page 2025

  38. [38]

    Yifan Song, Guoyin Wang, Sujian Li, and Bill Yuchen Lin. 2025. The Good, The Bad, and The Greedy: Evaluation of LLMs Should Not Ignore Non-Determinism. InProceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), Luis ProjAgent: Procedural...

    work page doi:10.18653/v1/2025.naacl-long.211 2025

  39. [39]

    William Timkey and Marten Van Schijndel. 2021. All bark and no bite: Rogue dimensions in transformer language models obscure representational quality. InProceedings of the 2021 Conference on Empirical Methods in Natural Language Processing. 4527–4546

    work page 2021

  40. [40]

    Henrique Schechter Vera, Sahil Dua, Biao Zhang, Daniel Salz, Ryan Mullins, Sindhu Raghuram Panyam, Sara Smoot, Iftekhar Naim, Joe Zou, Feiyang Chen, et al. 2025. Embeddinggemma: Powerful and lightweight text representations. arXiv preprint arXiv:2509.20354(2025)

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  41. [41]

    Ruiqi Wang, Jiyu Guo, Cuiyun Gao, Guodong Fan, Chun Yong Chong, and Xin Xia. 2025. Can llms replace human evaluators? an empirical study of llm-as-a-judge in software engineering.Proceedings of the ACM on Software Engineering2, ISSTA (2025), 1955–1977

    work page 2025

  42. [42]

    Yifei Wang, Ziteng Wang, Yuling Shi, Silin Chen, Xinrui Wang, Yueqi Wang, Beijun Shen, Linjing Li, Xiaodong Gu, Julian McAuley, et al. 2026. Context Compression for LLM Agents: A Survey of Methods, Failure Modes, and Evaluation. (2026)

    work page 2026

  43. [43]

    Xiaomin Yu, Yi Xin, Yuhui Zhang, Wenjie Zhang, Chonghan Liu, Hanzhen Zhao, Chen Liu, Xiaoxing Hu, Ziyue Qiao, Hao Tang, et al. 2026. Modality gap-driven subspace alignment training paradigm for multimodal large language models.arXiv preprint arXiv:2602.07026(2026)

    work page internal anchor Pith review Pith/arXiv arXiv 2026

  44. [44]

    Fengji Zhang, Bei Chen, Yue Zhang, Jacky Keung, Jin Liu, Daoguang Zan, Yi Mao, Jian-Guang Lou, and Weizhu Chen

    work page

  45. [45]

    InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing

    Repocoder: Repository-level code completion through iterative retrieval and generation. InProceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. 2471–2484

    work page 2023

  46. [46]

    Kechi Zhang, Jia Li, Ge Li, Xianjie Shi, and Zhi Jin. 2024. Codeagent: Enhancing code generation with tool-integrated agent systems for real-world repo-level coding challenges. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 13643–13658

    work page 2024

  47. [47]

    Sheng Zhang, Yifan Ding, Shuquan Lian, Shun Song, and Hui Li. 2025. CodeRAG: Finding Relevant and Necessary Knowledge for Retrieval-Augmented Repository-Level Code Completion. InProceedings of the 2025 Conference on Empirical Methods in Natural Language Processing. 23289–23299

    work page 2025

  48. [48]

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. 2024. Autocoderover: Autonomous program improvement. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. 1592–1604

    work page 2024

  49. [49]

    Ningyan Zhu, Huacan Wang, Jie Zhou, Feiyu Chen, Shuo Zhang, Ge Chen, Chen Liu, Jiarou Wu, Wangyi Chen, Xiaofeng Mou, et al. 2026. SemaClaw: A step towards general-purpose personal AI agents through harness engineering. arXiv preprint arXiv:2604.11548(2026)

    work page internal anchor Pith review Pith/arXiv arXiv 2026

  50. [50]

    Terry Yue Zhuo, Minh Chien Vu, Jenny Chim, Han Hu, Wenhao Yu, Ratnadira Widyasari, Imam Nur Bani Yusuf, Haolan Zhan, Junda He, Indraneil Paul, et al. 2025. Bigcodebench: Benchmarking code generation with diverse function calls and complex instructions. InInternational Conference on Learning Representations, Vol. 2025. 66602–66656

    work page 2025

  51. [51]

    Albert Ziegler, Eirini Kalliamvakou, X Alice Li, Andrew Rice, Devon Rifkin, Shawn Simister, Ganesh Sittampalam, and Edward Aftandilian. 2022. Productivity assessment of neural code completion. InProceedings of the 6th ACM SIGPLAN international symposium on machine programming. 21–29

    work page 2022

  52. [52]

    Andy Zou, Long Phan, Sarah Chen, James Campbell, Phillip Guo, Richard Ren, Alexander Pan, Xuwang Yin, Mantas Mazeika, Ann-Kathrin Dombrowski, et al. 2023. Representation engineering: A top-down approach to ai transparency. arXiv preprint arXiv:2310.01405(2023)

    work page internal anchor Pith review Pith/arXiv arXiv 2023