Software Engineering · arXiv:2610.38800 v1 · submitted 28 Oct 2026 · 21 references
When Relevant Code Is Wrong: Runtime-Aware Context for AI Coding Agents
The paper says
“AI coding agents increasingly rely on retrieved code and development history to guide software changes. However, highly relevant artifacts may describe implementations that are inactive or incompatible with the target deployment.”
more of the abstract
Neither semantic similarity nor recency establishes whether retrieved information remains applicable under feature flags, architectural migrations, and deployment-specific configurations. We challenge relevance-oriented retrieval by introducing operational context validity, a task-, deployment-, and time-dependent criterion for determining whether software evidence can legitimately guide implementation decisions. We instantiate this new retrieval principle in CASE, an agent-agnostic framework that connects repository artifacts with runtime configurations and architectural evolution, classifies evidence as valid, invalid, or unknown, and generates context packages distinguishing actionable guidance from historical rationale and unresolved constraints. We investigate its feasibility through a reproducible preliminary evaluation involving six development tasks, 15 artifacts, and three deployments. Conventional retrieval exposes 16 incompatible artifact occurrences as actionable, whereas CASE excludes them while retaining all applicable artifacts under the prototype's reference rules. Recency filtering reduces valid recall to 0.43, while removing feature-flag evidence from CASE reduces it to 0.13. Although these results demonstrate feasibility rather than improvements in coding-agent correctness, they reveal limitations of relevance-based retrieval and motivate a new research direction: enabling coding agents to reason not only about which information is relevant, but also whether it remains operationally valid.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 31 Oct 2026 · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up, with conditions. A clean conceptual separation of relevance from operational validity, with an honestly scoped pilot whose perfect scores are definitional; worth serious refereeing for the idea, but the central hypothesis needs independent evaluation. This line is wrong
3 major objections · 4 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the 21 references say.
The paper says, at Section II ('Core hypothesis') and Section IV, Table I
The review did not quote this passage.
A classifier read this sentence of the paper as acknowledging the concern (probability 0.77):
“Furthermore, the evaluation measures context selection, not the correctness of coding-agent decisions or generated patches.”
Pith says: Objection 1 of 3 · major
The core hypothesis predicts a reduction in deployment-incompatible implementation decisions, but the experiment's outcome variable is the composition of the retrieved context, not a decision. The headline 16-to-0 contrast is produced in part by the stipulated actionability convention: for Semantic Only, every retrieved artifact is counted as actionable, whereas for CASE only ACT ON items count.
more of objection 1
The reference labels also follow the same rules implemented by CASE's evaluator. The authors acknowledge both points in the Limitations paragraph of Section IV, so I do not treat the circularity as a new defect; the unresolved issue is that no part of the causal chain from validity-labeled packages to changed agent behavior is tested. The abstract and conclusion should either re-state the 16-to-0 result as a package-composition result under the prototype's reference rules, or the paper should add a small downstream measurement, such as whether an LLM agent's plan or patch differs and whether the difference reduces deployment conflicts.
The paper says, at Section III Step 1, Eq. (1), and Table I ('CASE w/o Flags')
The review did not quote this passage.
Pith says: Objection 2 of 3 · major
Eq. (1) makes the usefulness of V depend on 'sufficiently authoritative, non-conflicting evidence,' but the pilot's context graph is manually curated and the applicability conditions are hand-written, so no evidence-recovery failure mode is exercised. The ablation in Table I shows that removing feature-flag evidence collapses CASE's valid recall from 1.00 to 0.13, which is precisely the regime that real deployment manifests, flag configurations, and migration records are likely to exhibit; the paper itself cites toggle-lifecycle messiness in [7] and [19].
more of objection 2
The manuscript should either add an evidence-completeness or conflict sweep, include a small real-system case study, or explicitly state that the feasibility claim assumes complete authoritative evidence. As written, the central mechanism is untested in the conditions where it matters most.
The paper says, at Section III Step 2 and Section IV, Table I
The review did not quote this passage.
Pith says: Objection 3 of 3 · major
The tri-state design (valid/invalid/unknown) is presented as a central contribution, but the evaluation records zero unknown artifacts presented as actionable by CASE and does not measure what an agent does with VERIFY items. Since Section III Step 2 states that unknowns 'may trigger a question or additional retrieval,' the framework's behavior under uncertainty is unspecified and untested.
more of objection 3
A minimal addition would be reporting unknown counts under incomplete evidence and measuring how often the agent abstains, asks a question, or performs additional retrieval when VERIFY items are present.
4 minor objections
The paper says, at Section IV, 'Prototype and Experimental Setup'
Pith says: minor objection 1 of 4
The baseline is called 'Semantic Only' while the candidate pool is produced by a BM25 retriever; please clarify whether the relevance ranking is lexical, semantic, or a combination, since the paper's terminology around 'semantic' versus 'relevant' is otherwise central to the argument.
The paper says, at Abstract and Section VIII
Pith says: minor objection 2 of 4
The abstract and conclusion state that conventional retrieval 'exposes 16 incompatible artifact occurrences as actionable,' but the body (Section IV and the abstract's later clause) appropriately conditions this on the prototype's reference rules; the conditioning should appear in the abstract's headline sentence as well.
show 2 more
The paper says, at Figure 1
Pith says: minor objection 3 of 4
The figure text appears to run words together near 'Unresolved constraintslinked evidencegraph'; please fix the spacing or wrapping so the figure is legible.
The paper says, at Section IV, 'Prototype and Experimental Setup'
Pith says: minor objection 4 of 4
The 180-day recency window, top-8 pool size, and approximately 1,500-token budget are fixed without sensitivity analysis; a sentence noting that these were chosen without tuning, or reporting a small sensitivity check, would strengthen reproducibility.
What would settle it
Re-run the evaluation end-to-end on a real repository with a documented feature-flag and migration history (e.g., an Apache project with flag-configuration commits), constructing CASE packages purely from repository manifests, flag configuration files, and change history without manual curation. Obtain independent validity labels by having two annotators judge each artifact against the actual deployment state, with disagreements adjudicated. Then run an actual coding agent (SWE-agent style) on each task with either a similarity-only package or a CASE package at equal token budgets, and measure (1) agreement between CASE's automated labels and the independent labels, plus the fraction of retrieved artifacts labeled unknown, and (2) the rate of deployment-incompatible implementation decisions (patches that enable, modify, or rely on disabled or superseded paths).
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 31 Oct 2026
- Reader holds up, with conditions
- Skeptic partly agrees
- Editor wrote the verdict above
- Referee major revision: 3 major objections, 4 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
The useful thing here is a clean conceptual wedge: relevance and operational validity are different axes, and the paper makes that precise in Eq. (1), then keeps the two apart in the context package (ACT ON vs EXPLAIN vs VERIFY). I don't see that separation in the cited prior work. The feature-flag ablation (Table I) is the most informative number in the paper, not because it proves effectiveness, but because it shows the labels are not decoration: the whole benefit depends on recovering flag evidence. The replication package is public and the pilot is a deterministic replay, which is more than many papers at this stage do.
I also credit the Limitations paragraph (b119–b123). The authors say plainly that the pilot is a feasibility check, that the reference labels follow the same rules as the evaluator, and that context selection is not agent correctness. The abstract and conclusion stay within that scope. Too many papers use that caveat after overclaiming; here it matches the actual claims.
The soft spot is the one the authors concede, but it is still load-bearing: the pilot cannot support the central hypothesis in Section II. That hypothesis is about reducing deployment-incompatible implementation decisions. What is measured is package composition under a fixture whose ground truth is generated by the same rules the evaluator implements, so the perfect scores follow definitionally. The 16-to-0 reduction in Table I is partly built into the actionability convention: conventional retrieval counts every retrieved artifact as actionable, CASE counts only ACT ON items. That is a defensible modeling choice, but it converts the label outputs into the outcome.
Two links in the causal chain are unmeasured, and the stress-test note is right about both. First, recovering authoritative runtime evidence from real manifests, flag configs, and routing records is not tested; the context graph is manually curated. The ablation shows what happens if that link fails: remove flag evidence and valid recall collapses from 1.00 to 0.13. Second, nothing measures whether an agent given ACT ON / VERIFY / EXPLAIN packages actually makes fewer incompatible changes or spends the ~1,500-token budget any differently. Unknowns are supposed to trigger questions or additional retrieval (Step 2), but no unknown is reported as actionable, so that route is untested.
None of this makes the paper unsound on its own terms. It is honestly scoped. The risk is that a reader treats Table I as evidence the framework works, when it is evidence that a classifier can reproduce its own reference rules. This is still the right experiment to run next, with independent ground truth or real-task replays.
Who it is for: people working on retrieval context for repo-level coding agents, especially for configurable or migrating systems. I would send it to a serious referee rather than desk-rejecting. The formulation is clean, the direction is timely, and the authors are clear about what remains to be shown. My recommendation would be conditional acceptance pending an evaluation with independent labels or real tasks.
The strongest objection
The load-bearing gap is whether the causal chain in the core hypothesis (Sec. II) holds: holding model, pool, and token budget fixed, validity-labeled packages reduce deployment-incompatible implementation decisions. The pilot measures package composition, not decisions, and its actionability convention carries the load: for Semantic Only, every retrieved artifact counts as actionable; for CASE, only ACT ON items count (Sec. IV). The headline 16-to-0 reduction (Table I, b8) is thus partly definitional: it follows as soon as CASE's classifier reproduces the reference rules, which the fixture guarantees because the reference labels are generated by the same rules the evaluator implements (b119, b121; the authors acknowledge this). Two links in the chain are untested. First, evidence recovery: Eq. (1) requires 'sufficiently authoritative, non-conflicting evidence' to avoid unknown, but the pilot's context graph is manually curated (b119), and the cited toggle studies [7], [19] document lifecycle messiness that real manifests, flag configurations, and routing records must overcome. The paper's own ablation exposes the fragility: removing flag evidence drops CASE's valid recall from 1.00 to 0.13 (Table I), so the regime of incomplete real-world evidence could erase the benefit. Second, agent behavior: the framework states unknowns 'may trigger a question or additional retrieval' (Sec. III Step 2), but Table I reports zero unknown artifact occurrences as actionable, so how an agent spends a ~1,500-token budget across ACT ON, VERIFY, and EXPLAIN content, and whether labels change its plan, is unmeasured (b122 concedes only context selection is measured; b114 leaves agent inference from raw config open). If recovery yields mostly unknowns, or agents treat VERIFY items as usable, the predicted reduction does not transfer.
The paper is honest and well scoped, and it deserves credit where credit is due. The relevance-versus-validity distinction is real, and the pilot demonstrates it non-trivially: semantic retrieval surfaces 16 incompatible artifact occurrences (Table I), recency filtering both loses recall (0.43) and, after the European rollback, retains four artifacts that are all incompatible (b108), and CASE's deployment-dependent selection (GraphQL for us-prod, REST for eu-prod; b118) shows the contextual character of validity. The deterministic replay and public replication package make the pilot reproducible. The authors also state plainly that perfect precision/recall is expected under the fixture's assumptions (b121) and that only context selection, not downstream correctness, is measured (b122).
The residual gap I identify is more load-bearing than any single acknowledged limitation because it spans what remains untested between two acknowledged points. The core hypothesis is a causal claim about agent decisions: 'evidence packages that distinguish valid, invalid, and unknown artifacts will reduce deployment-incompatible implementation decisions' (Sec. II). The pilot's dependent variable is package composition, and the comparison is mediated by an actionability convention (all retrieved = actionable for Semantic Only; only ACT ON = actionable for CASE). Under that convention, the 16-to-0 reduction is guaranteed by the classifier being correct, and classifier correctness is established against labels generated by the same rules (b119, b121). So the circularity the reader flags is real, and I extend it: even a perfectly validated classifier would not settle the hypothesis unless agents actually change their decisions when given ACT ON / VERIFY / EXPLAIN packages, and unless real evidence yields definitive labels rather than unknowns.
Two internal signals strengthen the concern. First, CASE without flag evidence drops valid recall from 1.00 to 0.13 (Table I): the framework's benefit is extremely sensitive to the completeness of runtime evidence, and the cited feature-toggle literature (e.g., [7], [19]) documents exactly the fragmentation and persistence that would produce incomplete evidence in practice. Second, the unknown branch, the framework's distinctive three-valued behavior, is behaviorally invisible in the results: zero unknown artifact occurrences are presented as actionable, and the paper does not report how VERIFY items are consumed. The fixture's APAC deployment contains unresolved cohort information, yet the reported counts show no effect from that ambiguity, so the framework's behavior under genuine uncertainty is unobservable in the metrics.
The concrete test settles the matter in one design: reconstruct labels from real, non-curated evidence, check them against independent annotation, and measure the downstream decision rate the hypothesis names.
The referee's report
If the central hypothesis is correct, the paper identifies a real blind spot in coding-agent context construction: semantic relevance and recency are both deployment-blind, and the same repository state can legitimately support different implementations across deployments. The conceptual separation of topical relevance R from prescriptive validity V, the tri-state handling of unknown evidence, and the deployment- and time-dependent labeling in Eq. (1) are clean and useful foundations for a new line of work. The paper also ships a replication package, states a falsifiable prediction about where gains should concentrate (systems with migrations or configuration-dependent execution), and is unusually explicit about its own limitations. The empirical payload, however, is thin: the pilot is synthetic, small, manually curated, and its perfect scores are generated by the same rules the evaluator implements. The significance of the paper therefore rests primarily on the problem formulation and research agenda rather than on demonstrated downstream benefit.
Pith's reading of the paper (a machine's summary, not the authors')
This paper claims that relevance alone is the wrong retrieval criterion for AI coding agents: retrieved code, pull requests, and documentation can be highly relevant to a task yet describe implementations disabled by feature flags, superseded by migrations, or rolled back in a particular region. It introduces operational context validity, a deployment- and time-dependent property, and proposes CASE, a framework that classifies each candidate artifact as valid, invalid, or unknown against timestamped runtime evidence and packages the result for an existing agent. In a six-task synthetic fixture, the framework excluded 16 incompatible artifact occurrences that similarity retrieval presented as actionable while retaining all applicable artifacts, whereas recency filtering and a flag-free ablation lost most of the valid evidence. The authors state explicitly that these numbers demonstrate feasibility rather than gains in agent correctness, and that a real-world test with independent ground truth remains open. If the hypothesis holds, coding agents would stop treating relevant-but-incompatible history as actionable guidance.
What carries the argument. The load-bearing object is the prescriptive applicability function $V(a\mid d,t)$ (Eq. 1), which assigns each candidate artifact one of three labels — valid, invalid, or unknown — by checking whether timestamped runtime evidence $E_t$ entails or refutes the artifact's applicability conditions $\pi_a(d)$. The function is evaluated over a small, versioned context graph whose nodes are artifacts, implementations, flags, deployments, and services, and whose edges record guards, deployed-in, calls, and supersedes relations; a definitive label requires authoritative, non-conflicting evidence, and absence from sampled runtime traces is explicitly not treated as evidence of inapplicability. The third piece is the context package $P_B(q,d,t)$, a token-budgeted document that lists applicable artifacts as ACT ON, obsolete ones as EXPLAIN with historical rationale, and unresolved ones as VERIFY, attaching provenance, scope, and timestamps to every claim. Together the function, the graph, and the packaging are what separate the criterion of relevance from the criterion of current applicability.
Core claim. The paper's central claim is that topical relevance $R(a,q)$ and operational validity $V(a\mid d,t)$ are distinct properties of retrieved evidence, and that coding agents need the latter to make safe implementation decisions. An artifact is valid for deployment $d$ at time $t$ when timestamped evidence — deployment manifests, flag assignments, service routing, and migration and retirement records — entails the preconditions $\pi_a$ under which its implementation applies; it is invalid when the evidence refutes those preconditions, and unknown when evidence is missing or contradictory. The authors instantiate this in CASE, which reconstructs a small versioned context graph over artifacts, implementations, flags, deployments, and services, classifies each candidate artifact, and packages the result under a token budget as ACT ON, EXPLAIN, or VERIFY. In the pilot, CASE retained all applicable artifacts while excluding 16 incompatible occurrences that semantic retrieval presented as actionable; recency filtering reduced valid recall to 0.43, and removing feature-flag evidence reduced CASE's recall to 0.13. The paper explicitly frames these results as a proof of feasibility, not a measurement of downstream agent correctness.
The premise it rests on. The load-bearing premise is that authoritative, non-conflicting runtime evidence — deployment manifests, flag assignments, service routing, and migration records — can be recovered in enough completeness to label each candidate artifact valid or invalid, since the promised reduction in incompatible choices disappears if missing or contradictory evidence pushes most artifacts into 'unknown.'
If the paper is right (Pith's inferences, not the authors')
In systems with feature flags, regional rollbacks, or architectural migrations, a coding agent consuming a validity-aware package should stop proposing changes built on disabled or superseded implementations while keeping that history available as labeled explanation.
Context selection becomes a function of task, deployment, and time: replaying the same request against different deployments flips the actionable evidence between the GraphQL and REST implementations, so retrieval results cannot be treated as a single repository-wide set.
Merely adding raw configuration text to the retrieval pool does not change what the agent treats as actionable; the paper's comparison indicates the gain comes from explicit classification and separation of evidence, not from the availability of the configuration.
For stable, single-configuration components, the paper expects little or no benefit from validity labeling, which marks the boundary where retrieval as usual remains sufficient.
Because recency filtering retained four incompatible artifacts for the post-rollback European task while dropping valid ones, the paper positions recency as a weak proxy for validity rather than a replacement for it.
Editorial extension: the valid/invalid/unknown trichotomy is effectively an abstention mechanism; applied more broadly, any retrieval-augmented system over an evolving corpus could use the 'unknown' bucket to decline to act when evidence is insufficient, turning retrieval error into an explicit signal rather than a silent failure.
The ablation results suggest flag and rollout evidence carries most of the deployment-compatibility signal, with architectural lineage adding nothing in this fixture; a testable extension would measure whether flag-derived labels alone, without any lineage graph, already deliver most of CASE's precision on real tasks.
If the hypothesis survives real-world tests, context packages should be treated as versioned, deployment-scoped artifacts regenerated on flag changes and rollout events rather than cached by task similarity, since a stale package would go wrong in exactly the way the paper describes for stale code.
The paper's authority ordering — a versioned flag assignment outweighs absence from sampled logs — hints at a general provenance ranking for runtime evidence that future systems could formalize to resolve conflicts between evidence sources automatically.
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
AI coding agents increasingly rely on retrieved code and development history to guide software changes. However, highly relevant artifacts may describe implementations that are inactive or incompatible with the target deployment. Neither semantic similarity nor recency establishes whether retrieved information remains applicable under feature flags, architectural migrations, and deployment-specific configurations. We challenge relevance-oriented retrieval by introducing operational context validity, a task-, deployment-, and time-dependent criterion for determining whether software evidence can legitimately guide implementation decisions. We instantiate this new retrieval principle in CASE, an agent-agnostic framework that connects repository artifacts with runtime configurations and architectural evolution, classifies evidence as valid, invalid, or unknown, and generates context packages distinguishing actionable guidance from historical rationale and unresolved constraints. We investigate its feasibility through a reproducible preliminary evaluation involving six development tasks, 15 artifacts, and three deployments. Conventional retrieval exposes 16 incompatible artifact occurrences as actionable, whereas CASE excludes them while retaining all applicable artifacts under the prototype's reference rules. Recency filtering reduces valid recall to 0.43, while removing feature-flag evidence from CASE reduces it to 0.13. Although these results demonstrate feasibility rather than improvements in coding-agent correctness, they reveal limitations of relevance-based retrieval and motivate a new research direction: enabling coding agents to reason not only about which information is relevant, but also whether it remains operationally valid.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-10-30
The authors' main claim, as the classifier picked it out 0.95
“Although these results demonstrate feasibility rather than improvements in coding-agent correctness, they reveal limitations of relevance-based retrieval and motivate a new research direction: enabling coding agents to reason not only about which information is relevant, but also whether it remains operationally valid.”
How the main claim is stated: asserted 0.90
What the abstract itself states, as probabilities: claims first 0.10 · states limitation 0.97 · human participants 0.08 · controlled comparison 0.78 · randomized assignment 0.02 · states quantitative result 0.98 · compares with prior results 0.93 · mentions code or data availability 0.09
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| AI coding agents increasingly rely on retrieved code and development history to guide software changes. | background 1.00 | 0.04 | 0.02 | asserted 0.99 |
| However, highly relevant artifacts may describe implementations that are inactive or incompatible with the target deployment. | background 0.72 | 0.07 | 0.04 | hedged possibility 0.86 |
| Neither semantic similarity nor recency establishes whether retrieved information remains applicable under feature flags, architectural migrations, and deployment-specific configurations. | gap 0.92 | 0.12 | 0.07 | asserted 1.00 |
| We challenge relevance-oriented retrieval by introducing operational context validity, a task-, deployment-, and time-dependent criterion for determining whether software evidence can legitimately guide implementation decisions. | contribution 1.00 | 0.78 | 0.21 | asserted 0.98 |
| We instantiate this new retrieval principle in CASE, an agent-agnostic framework that connects repository artifacts with runtime configurations and architectural evolution, classifies evidence as valid, invalid, or unknown, and generates context packages distinguishing actionable guidance from historical rationale and unresolved constraints. | contribution 0.55 | 0.94 | 0.10 | asserted 1.00 |
| We investigate its feasibility through a reproducible preliminary evaluation involving six development tasks, 15 artifacts, and three deployments. | method 0.85 | 0.95 | 0.03 | asserted 0.93 |
| Conventional retrieval exposes 16 incompatible artifact occurrences as actionable, whereas CASE excludes them while retaining all applicable artifacts under the prototype's reference rules. | result 1.00 | 0.93 | 0.17 | asserted 1.00 |
| Recency filtering reduces valid recall to 0.43, while removing feature-flag evidence from CASE reduces it to 0.13. | result 1.00 | 0.92 | 0.08 | asserted 1.00 |
| Although these results demonstrate feasibility rather than improvements in coding-agent correctness, they reveal limitations of relevance-based retrieval and motivate a new research direction: enabling coding agents to reason not only about which information is relevant, but also whether it remains operationally valid. | interpretation 0.75 | 0.88 | 0.82 | asserted 0.90 |
What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 0.99
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-10-30: 1 request, 6,908 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (1)
References (21)
- [7] M. T. Rahman, L.-P. Querel, P. C. Rigby, and B. Adams, “Feature toggles: Practitioner practices and a case study,” inProceedings of the 13th International Conference on Mining Software Repositories. ACM, 2016, pp. 201–211 on Pith
- [19] J. Hoyos, R. Abdalkareem, S. Mujahid, E. Shihab, and A. E. Bedoya, “On the removal of feature toggles,”Empirical Software Engineering, vol. 26, no. 1, p. 15, 2021 on Pith
- [1] J. Yang, C. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “Swe-agent: Agent-computer interfaces enable automated software engineering,”Advances in Neural Information Processing Systems, vol. 37, pp. 50 528–50 652, 2024 on Pith
- [2] X. Yin, Y . Zhang, Z. Peng, C. Ni, Z. Cui, and X. Xin, “Chronos enables code agents to reason over software evolution,” 2026. [Online]. Available: https://arxiv.org/abs/2610.11578 on PithPith's reviewarXiv
- [3] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan, “SWE-bench: Can language models resolve real-world GitHub issues?” inInternational Conference on Learning Representations (ICLR), 2024. [Online]. Available: https://openreview. net/forum?id=VTF8yNQM66 on Pith
- [4] W. Gu, J. Chen, Y . Wang, T. Jiang, X. Li, M. Liu, X. Liu, Y . Ma, and Z. Zheng, “What to retrieve for effective retrieval-augmented code generation? an empirical study and beyond,” inInternational Conference on Software Engineering (ICSE), 2026. [Online]. Available: https://a... on PithPith's reviewarXiv
- [5] S. Ouyang, W. Yu, K. Ma, Z. Xiao, Z. Zhang, M. Jia, J. Han, H. Zhang, and D. Yu, “RepoGraph: Enhancing AI software engineering with repository-level code graph,” inInternational Conference on Learning Representations (ICLR), 2025. [Online]. Available: https://arxiv.org/abs/2410.14684 on PithPith's reviewarXiv
- [6] A. Lercher, J. Glock, C. Macho, and M. Pinzger, “Microservice api evolution in practice: A study on strategies and challenges,”Journal of Systems and Software, vol. 215, p. 112110, 2024 on Pith
- [8] H. M. Ayas, P. Leitner, and R. Hebig, “An empirical study of the systemic and technical migration towards microservices,”Empirical Software Engineering, vol. 28, no. 4, p. 85, 2023 on Pith
- [9] S. Ducasse and D. Pollet, “Software architecture reconstruction: A process-oriented taxonomy,”IEEE Transactions on Software Engineering, vol. 35, no. 4, pp. 573–591, 2009 on Pith
- [10] H. Weng, Q. Yang, H. Fu, H. Pan, and X. Lv, “When retrieval hurts code completion: A diagnostic study of stale repository context,” 2026, arXiv:2605.14478. [Online]. Available: https://arxiv.org/abs/2605.14478 on PithPith's reviewarXiv
- [11] D. Wu, W. U. Ahmad, D. Zhang, M. K. Ramanathan, and X. Ma, “Repoformer: Selective retrieval for repository-level code completion,” inProceedings of the 41st International Conference on Machine Learning, ser. Proceedings of Machine Learning Research, vol. 235. PMLR, 2024, pp. 5... on Pith
- [12] C. Duan, G. Shi, Z. Mao, G. Zhang, H. Liang, Y . Piao, Y . Wu, Z. Yao, K. Huang, W. Huang, L. Sun, S. Yan, and W. Zhang, “Repo2Skill-Evo: Repository skills go stale in silence,” 2026. [Online]. Available: https://arxiv.org/abs/2608.21964 on PithPith's reviewarXiv
- [13] S. Robertson and H. Zaragoza, “The probabilistic relevance framework: Bm25 and beyond,”Foundations and trends® in information retrieval, vol. 4, no. 1-2, pp. 1–174, 2009 on Pith
- [14] W. K. G. Assunção and R. Periyathambi, “CASE Merchant Trust: A prototype for runtime-aware software context validation,” GitHub repository, 2026, prototype, synthetic evaluation dataset, experimental scripts, and results. [Online]. Available: https://github.com/ rameshperiyath... on Pith
- [15] N. L. Hai, D. M. Nguyen, and N. D. Q. Bui, “On the impacts of contexts on repository-level code generation,” inFindings of the Association for Computational Linguistics: NAACL, 2025, pp. 1496–1524 on Pith
- [16] W. Cheng, Y . Wu, and W. Hu, “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). Association for Computational Linguistics, 2024, pp. 7957– on Pith
- [17] H. N. Phan, H. N. Phan, T. N. Nguyen, and N. D. Q. Bui, “RepoHyper: Search–expand–refine on semantic graphs for repository-level code completion,” inProceedings of the Second IEEE/ACM International Con- ference on AI Foundation Models and Software Engineering (FORGE), 2025 on Pith
- [18] T. Mehtiyev and W. Assunção, “Beyond resolution rates: Behavioral drivers of coding agent success and failure,” 2026, arXiv:2604.02547. [Online]. Available: https://arxiv.org/abs/2604.02547 on PithPith's reviewarXiv
- [20] R. Mahdavi-Hezaveh, S. Fatima, and L. Williams, “Paving a path for a combined family of feature toggle and configuration option research,” ACM Transactions on Software Engineering and Methodology, vol. 33, no. 7, 2024 on Pith
show 1 more
- [7977] [Online]. Available: https://aclanthology.org/2024.acl-long.431/ on Pith
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.

No comments yet.
Sign in to comment