Pith. sign in

REVIEW 5 major objections 5 minor 87 references

Risk Assessment Framework for Code LLMs via Leveraging Internal States

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

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

Pith's one-line read A two-stage pretraining method reads a code LLM's internal states to flag erroneous output lines, and claims this signal transfers across coding tasks and languages.

desk verdict A useful new line-level risk flag for code LLMs with public artifacts and held-out gains, but the SOTA claim needs a length-only baseline and error bars before it is credible. read the letter →

arxiv 2504.14640 v1 pith:ML6D5IHQ submitted 2025-04-20 cs.SE cs.AIcs.CL

Yuheng Huang , Lei Ma , Keizaburo Nishikino , Takumi Akazaki This is my paper · ORCID
classification cs.SEcs.AIcs.CL
keywords largelanguagemodelscodegenerationriskassessmentinternalstatessparseautoencodersline-levelerrordetectionlearningtoranktrustworthinessassurance
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

PtTrust is a two-stage framework for assessing risk in code generated by large language models, aimed at flagging the specific lines of an incorrect answer rather than judging the whole snippet. In a first, unsupervised stage it compresses the model's hidden states, taken only at the newline token of each code line from early layers, with a TopK sparse autoencoder trained on large amounts of unlabeled code, including deliberately mutated lines. In a second, supervised stage, a small labeled Python-only dataset of about 368 snippets teaches a learning-to-rank network to score each line by risk. The paper claims this setup reaches state-of-the-art Top-K hit rates for identifying erroneous lines on three open code LLMs across code editing, translation, and repair, including a Java task the classifier never saw during training. The significance is that risk assessment could piggyback on the same pretraining paradigm as the LLM itself, using abundant unlabeled company code and only a little human feedback.

What carries the argument

The central object is a $\mathrm{TopK}$ sparse autoencoder applied to hidden states at the newline token of each code line, drawn from the first quarter of the LLM's layers. The encoders computes $z = \mathrm{TopK}(W_{\mathrm{enc}}(s-b_{\mathrm{pre}})+b_{\mathrm{enc}})$, keeping only the $k$ largest latent values, and the decoder reconstructs $\hat{s}=W_{\mathrm{dec}}z+b_{\mathrm{pre}}$; training minimizes a plain reconstruction loss plus a contrastive loss on pairs of correct and mutated lines. This machinery reduces the high-dimensional internal state to a sparse, interpretable code, and the same frozen latents afterwards feed a learning-to-rank network trained with NeuralNDCG. The key work it does is to disentangle representation from computation: unsupervised pretraining captures general error-related structure from unlabeled code, while only a small supervised stage binds that structure to specific risk labels.

What would settle it

Shuffle the order of code lines within each snippet before extracting newline-token states, or train the ranker on line length and position alone; if the Top-K hit rates stay about the same, the method's apparent generalization is explained by surface cues rather than by internal-state signals.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that correctness-relevant information survives in the hidden-state representation of a code LLM at line boundaries, and that a sparse, contrastively pretrained compression of those states transfers across tasks and languages. Given an incorrect generated answer $A$ of $n$ lines, PtTrust identifies a subset $E\subseteq A$ of erroneous lines by scoring each line from the sparse-autoencoder latent $z$ extracted at its terminating newline token. The autoencoder is trained with a reconstruction loss plus a contrastive loss that pushes apart latent representations of correct and mutated or incorrect lines; the downstream ranker uses NeuralNDCG to order lines by risk. In experiments with three large open-source code LLMs, PtTrust attains the highest Top-1, Top-3, and Top-5 hit rates on code editing and code translation for all three models and remains competitive on a Java repair benchmark, where an uncertainty baseline leads. It also reports state-of-the-art snippet-level error prediction in 7 of 9 cases, and shows that certain SAE latents activate consistently for erroneous lines across all evaluation datasets, which the authors liken to error-related signals observed in human brains.

Load-bearing premise

The load-bearing premise is that the hidden state at a line's newline token, taken from early layers and compressed by a contrastively trained sparse autoencoder, carries enough task-independent signal about that line's correctness that a small Python-only labeled set transfers to unseen tasks and languages.

Editorial extensions

If this is right

  • Companies could pretrain the risk probe on their own unlabeled code repositories, so that expensive human labels are needed only for a small semantic-binding set.
  • A Python-only labeled set is enough to produce useful line-level risk signals for unseen tasks such as code editing, translation, and repair, and for Java as well as Python.
  • Because the SAE latents are sparse and interpretable, a deployed risk flag can be explained by which latent features fire, not just by a single risk score.
  • The two-stage design keeps deployment cheap: a single forward pass per snippet plus a small ranking network, with no per-task retraining of the LLM.
  • The same semantic-binding mechanism could in principle bind the same representations to other risk properties, such as security or performance, by changing the labels collected in stage two.

Reading between the lines

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

  • Editorial inference: the decisive experiment the paper does not report is an ablation that removes the SAE pretraining stage; if a classifier trained directly on raw newline-token states matched PtTrust's Top-K scores, the pretraining story would be unnecessary.
  • Editorial inference: because line-level signals are read at newline tokens, the transfer claim could be stress-tested on minified code or code written without line breaks, or on languages with different line conventions; the current evaluation only covers Python and Java.
  • Editorial inference: the contrastive mutations, line swaps and line deletions, create errors that differ in kind from natural LLM errors, so the claim that pretraining sees genuine mistakes hinges on how much these synthetic errors share with real ones; a test using only commit-history bugs for pretraining would clarify this.
  • Editorial inference: a cheap surface-feature baseline that ranks lines by length or position would establish whether the internal-state latents add signal beyond line statistics; the paper includes uncertainty baselines but no such control.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

5 major / 5 minor

Summary. The paper proposes PtTrust, a two-stage framework for line-level risk assessment of code LLMs based on internal states. Stage 1 profiles hidden states of a target code LLM at newline tokens in early layers, trains a TopK sparse autoencoder with a reconstruction loss plus a contrastive loss on correct/incorrect and mutated code pairs. Stage 2 uses a small Python-only labeled dataset (HumanEval, EvalPack, QuixBugs) to train a NeuralNDCG ranking model over SAE latents. The framework is evaluated on EditEval, Code Lingua, and Defects4j across three code LLMs, with Top-K Hit Rate for line-level identification and accuracy for snippet-level classification, and the authors claim state-of-the-art results and interpretable cross-task latent features.

Significance. If the claims hold, PtTrust would be a practical contribution: it would show that a small amount of labeled data plus unsupervised SAE pre-training on public code can produce a line-level risk flag that transfers across tasks and languages, with released implementation and labeled datasets. The paper also introduces a benchmark task (fine-grained code line error identification) and compares against reasonable baselines. However, the headline results are currently difficult to interpret because of a metric-label alignment confound, the absence of statistical reliability information, and the GPT-4o-derived labels. The interpretability result is largely a consequence of the training objective. With additional controls, the paper could be a solid empirical contribution.

major comments (5)
  1. [§3.3, §4.2, Tables 2-4] In §3.3 the incorrect training lines are ranked 'based on their length,' while the RQ1 metric in §4.2 is Top-K Hit Rate, defined as the proportion of buggy tokens covered by the selected lines. Because longer buggy lines contribute proportionally more tokens, a baseline that ranks lines by token count would be aligned with both the training target and the evaluation metric. No such baseline appears in Tables 2-4, so the reported state-of-the-art performance could be an artifact of metric-label alignment rather than evidence that newline-token hidden states carry transferable error information. Please add a length-only ranking baseline and, ideally, a variant of the Probing Classifier that includes line length as an input feature.
  2. [§4.2, Tables 2-4; §4.3, Table 5] All results are reported as single point estimates without variance, confidence intervals, or significance tests. Several comparisons are close or favor the Uncertainty baseline (e.g., Code Llama on Defects4j Top-5: PtTrust 0.595 vs Uncertainty 0.603; Qwen2.5-Coder on Defects4j: Uncertainty is higher at all K), so the 'state-of-the-art' claim is not yet supported. Please report multiple seeds or bootstrap confidence intervals and perform paired significance tests across instances where appropriate.
  3. [§4.1.1, Table 1; §6] Both the semantic-binding labels and the evaluation ground truth are produced by GPT-4o, and the manual verification procedure is applied only to cases where GPT-4o's repair attempts failed. The paper does not report how many cases were manually reviewed, how the review sample was drawn, or any agreement statistics between GPT-4o and human line-level annotations. Since the same labeling source is used in training and testing, a systematic labeling bias (e.g., toward longer lines or particular syntactic patterns) would be shared by both and could interact with the length confound in Major Comment 1. Please quantify label quality on a human-annotated held-out sample and report the manual-review counts.
  4. [§4.4.2, Eq. (4)] The SAE is trained with a contrastive loss that explicitly separates correct and incorrect/mutated line representations, so the observation that some latents are consistently more active for incorrect lines is expected from the objective rather than an emergent, independent property. This weakens Finding 3 and the comparison to human error-related negativity. To support the interpretability claim, compare with an SAE trained without the contrastive term (or with shuffled contrastive pairs) and report whether the same cross-task error latents appear.
  5. [§3.2, §3.3, §4] The central design choices are not ablated: no comparison with raw-state inputs under the same NeuralNDCG ranking objective, no removal of the contrastive loss, no sweep of the selected early layer or TopK sparsity k, and no evaluation of the different mutation types. Without these ablations, the paper's claim that the unsupervised SAE pre-training stage is responsible for cross-task and cross-language generalization is under-supported. Please add at least a no-contrastive SAE ablation and a raw-state + ranking baseline.
minor comments (5)
  1. [§4.2] The opening sentence 'PtTrust achieves state-of-the-art performance across all three code LLMs' is contradicted by the Defects4j results in Tables 2-4 (e.g., Uncertainty outperforms PtTrust for Qwen2.5-Coder on Defects4j). Please qualify the claim.
  2. [Tables 2-4] The captions mention that 'Different colors are used to highlight the best and second-best' but the colors are not described or visible in the text; add a legend or use boldface.
  3. [Footnote 1 and §3.3] The line-deletion contrastive pair definition (original line versus the line following the deleted line) is confusing; spell out how the 'incorrect' member is determined.
  4. [§3.3] The paper omits the NeuralNDCG loss definition and training hyperparameters; please provide the formula or a precise citation and the learning rate, batch size, and number of epochs.
  5. [References] References [60] and [61] appear to be the same paper (Pan et al., Lost in Translation) and should be merged.

Circularity Check

1 steps flagged · score 3.0 of 10

The held-out RQ1 result is independent, but the RQ3 interpretability 'surprise' re-states the contrastive training objective (Eq. 4), so the paper is mildly circular in that sub-claim.

  1. self definitional [Section 3.2 (Eq. 4) and Section 4.4.2 ('Feature Interpretability')]
    "we incorporate contrastive learning [11,34,39,83], which encourages the model to distinguish between the representations of correct and incorrect code lines. Specifically, the contrastive loss is defined as: Lcont(x_i,x_j,θ)=max(0, ε−||fθ(x_i)−fθ(x_j)||2)^2 ... In our study, these pairs are created in two ways: by using already-known correct and incorrect code lines or by comparing original code snippets with their mutated counterparts. ... we calculate the average latent activation of the SAE for both incorrect and correct code lines, then subtract the latter from the former. ..."

    The SAE encoder fθ is explicitly trained with Lcont on pairs labeled correct versus incorrect, so a larger representation distance between these two groups is a training objective, not an emergent discovery. RQ3's procedure computes the average activation difference between incorrect and correct lines and highlights positive latents, which is essentially a visualization of that same objective. Presenting the result as 'surprising' re-labels a by-construction outcome as an empirical finding. The cross-task transfer to held-out datasets retains some independent content, but the claim that the latents represent erroneous code lines is in part manufactured by the label-injecting contrastive loss rather than discovered from unlabeled internal states.

full rationale

The core RQ1 claim is not circular: PtTrust is trained on Python-only HumanEval, EvalPack, and QuixBug labels and evaluated on held-out EditEval, Code Lingua, and Defects4j tasks spanning Python and Java, so the line-level Top-K Hit Rate numbers are not entailed by the training inputs. Self-citations in the paper are contextual or design-supporting, not load-bearing; no uniqueness theorem or central premise reduces to an author-only citation. The interpretability finding in Section 4.4.2 is the one genuinely circular sub-claim: because the contrastive loss in Eq. 4 is explicitly trained on correct/incorrect pairs, finding that the SAE latents separate correct from incorrect lines is a restatement of the training objective, not an independent discovery. The paper's length-ranked semantic-binding labels and the token-weighted Top-K metric create a legitimate validity concern that a length-only baseline should be run, but that is an experimental-control issue rather than a derivation that is equivalent to its inputs, since the held-out evaluation labels are independent of the training targets. Overall, the central result stands on its own, so the circularity score is modest.

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

PtTrust rests on several domain assumptions: internal states encode correctness, newline tokens retain line-level information, early layers are appropriate, mutated code provides useful contrastive signal, and GPT-4o labels are valid ground truth. Most are flagged in the paper, but only the first and last are discussed in depth; the newline-token and mutation-transfer assumptions are not tested. The main free parameters are either unreported (k, epsilon, layer index) or fitted on training data (Youden threshold, length ranking).

free parameters (5)
  • TopK sparsity k and SAE latent dimension = not reported
    Section 3.2 defines z = TopK(...) but never reports k or the latent dimension, although these control how much information survives compression and are central to the claimed scalability.
  • Contrastive margin epsilon in Lcont = not reported
    Equation 4 defines the contrastive loss with a margin epsilon; the value chosen is not given, and it directly controls the separation between correct and incorrect line representations.
  • Selected early layer (first quarter of layers) = not reported
    Section 3.2 chooses early layers without a code-specific layer sweep; this choice is imported from NLP studies and could change results for code tasks.
  • Line-length ranking rule for incorrect training lines = longer lines ranked higher
    Section 3.3 assigns incorrect training lines a rank based on length, which aligns with the token-weighted Top-K Hit Rate metric and injects a length prior into supervision.
  • Youden's J threshold for snippet-level classification = optimized on the semantic-binding training set
    Section 4.3 selects the threshold using Youden's J on training data; no stability analysis is reported.
assumptions (5)
  • domain assumption LLM internal hidden states carry information about the correctness of generated code lines.
    Central premise of internal-state probing, inherited from Azaria and Mitchell [3] and used throughout Sections 3 and 4. It is not derived in the paper.
  • ad hoc to paper Hidden states at the newline token are sufficient to represent line-level correctness.
    Section 3.2 discards all non-newline tokens to cut cost; the paper asserts it mitigates next-token entanglement but provides no supporting analysis for code tasks.
  • domain assumption Early-layer activations correlate with high-level decisions, so the first quarter of layers is appropriate.
    Section 3.2 cites [26,28,30] for this; no code-specific validation or layer sweep is presented.
  • domain assumption GPT-4o line-level error labels are accurate enough to serve as ground truth.
    Section 4.1.1 uses GPT-4o to label errors with limited manual review; the paper itself lists this as a validity threat.
  • ad hoc to paper Line mutations (switch, delete) produce error patterns similar enough to real LLM mistakes that contrastive pre-training on them helps downstream risk prediction.
    Section 3.2 introduces three mutators; no ablation shows they help, and the paper notes finer mutators gave no significant improvement.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Risk Assessment Framework for Code LLMs via Leveraging Internal States." pith.science (2026). https://pith.science/paper/ML6D5IHQ

@misc{pith2026250414640,
  author       = {Pith},
  title        = {Pith review of: Risk Assessment Framework for Code LLMs via Leveraging Internal States},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ML6D5IHQ}},
  note         = {Machine review of arXiv:2504.14640}
}
read the original abstract

The pre-training paradigm plays a key role in the success of Large Language Models (LLMs), which have been recognized as one of the most significant advancements of AI recently. Building on these breakthroughs, code LLMs with advanced coding capabilities bring huge impacts on software engineering, showing the tendency to become an essential part of developers' daily routines. However, the current code LLMs still face serious challenges related to trustworthiness, as they can generate incorrect, insecure, or unreliable code. Recent exploratory studies find that it can be promising to detect such risky outputs by analyzing LLMs' internal states, akin to how the human brain unconsciously recognizes its own mistakes. Yet, most of these approaches are limited to narrow sub-domains of LLM operations and fall short of achieving industry-level scalability and practicability. To address these challenges, in this paper, we propose PtTrust, a two-stage risk assessment framework for code LLM based on internal state pre-training, designed to integrate seamlessly with the existing infrastructure of software companies. The core idea is that the risk assessment framework could also undergo a pre-training process similar to LLMs. Specifically, PtTrust first performs unsupervised pre-training on large-scale unlabeled source code to learn general representations of LLM states. Then, it uses a small, labeled dataset to train a risk predictor. We demonstrate the effectiveness of PtTrust through fine-grained, code line-level risk assessment and demonstrate that it generalizes across tasks and different programming languages. Further experiments also reveal that PtTrust provides highly intuitive and interpretable features, fostering greater user trust. We believe PtTrust makes a promising step toward scalable and trustworthy assurance for code LLMs.

Figures

Figures reproduced from arXiv: 2504.14640 by the authors.

Figure 1
Figure 1. The Summarized Workflow of PtTrust. making them a suitable choice for our analysis. Notably, this process involves only a single forward pass without any generation. This is analogous to brain studies, where researchers observe and record brain activity as participants read given materials [18, 55]. Since the ultimate goal is to assess the risks associated with the LLM, it is essential for our “participant”—the LLM—… view at source ↗
Figure 2
Figure 2. Distribution difference across tasks for three LLMs. The lower triangle represents the distance between each language pair in the LeetCode dataset, while the upper triangle shows the corresponding distances within the EvalPack dataset. The diagonal entries indicate the cross-task distance (LeetCode v.s. EvalPack) for the same language. Code Lingua EditEval Defects4J HumanEval QuixBugs EvalPack Latent Activation of S… view at source ↗
Figure 3
Figure 3. Activation difference between buggy and correct code lines on Code Llama. Latent 121 is highlighted. Code Lingua EditEval Defects4J HumanEval QuixBugs EvalPack Latent Activation of SAE [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: Activation difference between buggy and correct code lines on StarCoder2. Latent 44 is highlighted. Code Lingua EditEval Defects4J HumanEval QuixBugs EvalPack Latent Activation of SAE [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

87 extracted references · 40 canonical work pages

  1. [1]

    Leetcode Dataset

    2025. Leetcode Dataset. https://huggingface.co/datasets/greengerong/leetcode Accessed: 2025-01-13

    2025

  2. [2]

    Shushan Arakelyan, Rocktim Das, Yi Mao, and Xiang Ren. 2023. Exploring distributional shifts in large language models for code analysis. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing . 16298–16314

    2023

  3. [3]

    Amos Azaria and Tom Mitchell. 2023. The Internal State of an LLM Knows When It’s Lying. In The 2023 Conference on Empirical Methods in Natural Language Processing. https://openreview.net/forum?id=y2V6YgLaW7

    2023

  4. [4]

    Pierre Baldi. 2012. Autoencoders, unsupervised learning, and deep architectures. In Proceedings of ICML workshop on unsupervised and transfer learning . JMLR Workshop and Conference Proceedings, 37–49

    2012

  5. [5]

    Shraddha Barke, Michael B James, and Nadia Polikarpova. 2023. Grounded copilot: How programmers interact with code-generating models. Proceedings of the ACM on Programming Languages 7, OOPSLA1 (2023), 85–111

    2023

  6. [6]

    Travis Bricken, Alex Templeton, Joshua Batson, Benjamin Chen, Alan Jermyn, et al. 2023. Towards Monosemanticity: Decomposing Language Models with Dictionary Learning. Transformer Circuits Thread (2023)

    2023

  7. [7]

    Bei Chen, Fengji Zhang, Anh Nguyen, Daoguang Zan, Zeqi Lin, Jian-Guang Lou, and Weizhu Chen. 2023. CodeT: Code Generation with Generated Tests. In The Eleventh International Conference on Learning Representations

    2023

  8. [8]

    Junkai Chen, Xing Hu, Zhenhao Li, Cuiyun Gao, Xin Xia, and David Lo. 2024. Code search is all you need? improving code suggestions with code search. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering. 1–13

    work page 2024

Show all 87 references
  1. [9]

    Jianhui Chen, Xiaozhi Wang, Zijun Yao, Yushi Bai, Lei Hou, and Juanzi Li

  2. [10]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 (2021)

    2021 arXiv

  3. [11]

    Sumit Chopra, Raia Hadsell, and Yann LeCun. 2005. Learning a similarity metric discriminatively, with application to face verification. In 2005 IEEE computer society conference on computer vision and pattern recognition (CVPR’05) , Vol. 1. IEEE, 539–546

    2005

  4. [12]

    Yung-Sung Chuang, Linlu Qiu, Cheng-Yu Hsieh, Ranjay Krishna, Yoon Kim, and James R. Glass. 2024. Lookback Lens: Detecting and Mitigating Contex- tual Hallucinations in Large Language Models Using Only Attention Maps. In Proceedings of the 2024 Conference on Empirical Methods i...

    2024 doi

  5. [13]

    Kenneth L Clarkson. 1994. An algorithm for approximate closest-point queries. In Proceedings of the tenth annual symposium on Computational geometry . 160–164

    1994

  6. [14]

    Sourav Deb, Kush Jain, Rijnard Van Tonder, Claire Le Goues, and Alex Groce. 2024. Syntax Is All You Need: A Universal-Language Approach to Mutant Generation. Proceedings of the ACM on Software Engineering (FSE 2024) (2024)

    2024

  7. [15]

    Yangruibo Ding, Marcus J Min, Gail Kaiser, and Baishakhi Ray. 2024. CYCLE: Learning to Self-Refine the Code Generation. Proceedings of the ACM on Pro- gramming Languages 8, OOPSLA1 (2024), 392–418

    2024

  8. [16]

    Nelson Elhage, Tristan Hume, Catherine Olsson, Nicholas Schiefer, Tom Henighan, Shauna Kravec, Zac Hatfield-Dodds, Robert Lasenby, Dawn Drain, Carol Chen, et al . 2022. Toy models of superposition. arXiv preprint arXiv:2209.10652 (2022)

    2022 arXiv

  9. [17]

    Ronen Fluss, David Faraggi, and Benjamin Reiser. 2005. Estimation of the Youden Index and its associated cutoff point.Biometrical Journal: Journal of Mathematical Methods in Biosciences 47, 4 (2005), 458–472

    2005

  10. [18]

    Michael J Frank, Brion S Woroch, and Tim Curran. 2005. Error-related negativity predicts reinforcement learning and conflict biases. Neuron 47, 4 (2005), 495–501

    2005

  11. [19]

    Daniel Fried, Armen Aghajanyan, Jessy Lin, Sida Wang, Eric Wallace, Freda Shi, Ruiqi Zhong, Scott Yih, Luke Zettlemoyer, and Mike Lewis. 2023. InCoder: A Generative Model for Code Infilling and Synthesis. In The Eleventh International Conference on Learning Representations. ht...

    2023

  12. [20]

    Fujitsu Limited. 2024. Fujitsu launches “Takane” - A large language model for enterprises offering the highest Japanese language proficiency in the world. https://www.fujitsu.com/global/about/resources/news/press-releases/ 2024/0930-01.html Accessed: 2025-01-15

    2024

  13. [21]

    Fujitsu Limited. 2024. Fujitsu to provide the world’s first enterprise-wide generative AI framework technology to meet changing needs of compa- nies. https://www.fujitsu.com/global/about/resources/news/press-releases/ 2024/0604-01.html Accessed: 2025-01-15

    2024

  14. [22]

    Leo Gao, Tom Dupré la Tour, Henk Tillman, Gabriel Goh, Rajan Troll, Alec Radford, Ilya Sutskever, Jan Leike, and Jeffrey Wu. 2024. Scaling and evaluating sparse autoencoders. arXiv preprint arXiv:2406.04093 (2024)

    2024 arXiv

  15. [23]

    Shuzheng Gao, Xin-Cheng Wen, Cuiyun Gao, Wenxuan Wang, Hongyu Zhang, and Michael R Lyu. 2023. What makes good in-context demonstrations for code intelligence tasks with llms?. In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 761–773

    2023

  16. [24]

    Daya Guo, Qihao Zhu, et al . 2024. DeepSeek-Coder: When the Large Lan- guage Model Meets Programming–The Rise of Code Intelligence. arXiv preprint arXiv:2401.14196 (2024)

    2024 arXiv

  17. [25]

    Douglas M Hawkins. 2004. The problem of overfitting. Journal of chemical information and computer sciences 44, 1 (2004), 1–12

    2004

  18. [26]

    Jinwen He, Yujia Gong, Zijin Lin, Yue Zhao, Kai Chen, et al. 2024. Llm factoscope: Uncovering llms’ factual discernment through measuring inner states. InFindings of the Association for Computational Linguistics ACL 2024 . 10218–10230

    2024

  19. [27]

    Xinyi Hou, Yanjie Zhao, Yue Liu, Zhou Yang, Kailong Wang, Li Li, Xiapu Luo, David Lo, John Grundy, and Haoyu Wang. 2024. Large language models for software engineering: A systematic literature review. ACM Transactions on Software Engineering and Methodology 33, 8 (2024), 1–79

    2024

  20. [28]

    Yuheng Huang, Jiayang Song, Qiang Hu, Felix Juefei-Xu, and Lei Ma. 2024. Active Testing of Large Language Model via Multi-Stage Sampling.arXiv preprint arXiv:2408.03573 (2024)

    2024 arXiv

  21. [29]

    Yuheng Huang, Jiayang Song, Zhijie Wang, Shengming Zhao, Huaming Chen, Felix Juefei-Xu, and Lei Ma. 2025. Look before you leap: An exploratory study of uncertainty measurement for large language models. IEEE Transactions on Software Engineering (TSE) (2025)

    2025

  22. [30]

    Robert Huben, Hoagy Cunningham, Logan Riggs Smith, Aidan Ewart, and Lee Sharkey. 2024. Sparse Autoencoders Find Highly Interpretable Features in Lan- guage Models. InThe Twelfth International Conference on Learning Representations. https://openreview.net/forum?id=F76bwRSLeK

    2024

  23. [31]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, et al. 2024. Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186 (2024)

    2024 arXiv

  24. [32]

    Inbal Shani. 2025. Survey reveals AI’s impact on the developer experi- ence. https://github.blog/news-insights/research/survey-reveals-ais-impact-on- the-developer-experience/. Accessed: 2025-01-14

    2025

  25. [33]

    Kevin Jesse, Toufique Ahmed, Premkumar T Devanbu, and Emily Morgan. 2023. Large language models and simple, stupid bugs. In IEEE/ACM 20th International Conference on Mining Software Repositories (MSR) . 563–575

    2023

  26. [34]

    Nan Jiang, Chengxiao Wang, Kevin Liu, Xiangzhe Xu, Lin Tan, Xiangyu Zhang, and Petr Babkin. 2024. Nova: Generative Language Models for Assembly Code with Hierarchical Attention and Contrastive Learning. arXiv:2311.13721 [cs.SE] https://arxiv.org/abs/2311.13721

    2024

  27. [35]

    Xue Jiang, Yihong Dong, Lecheng Wang, Zheng Fang, Qiwei Shang, Ge Li, Zhi Jin, and Wenpin Jiao. 2024. Self-planning code generation with large language models. ACM Transactions on Software Engineering and Methodology 33, 7 (2024), 1–30

    2024

  28. [36]

    Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik R Narasimhan. 2024. SWE-bench: Can Language Models Resolve Real-world Github Issues?. In The Twelfth International Conference on Learning Representations. https://openreview.net/forum...

    2024

  29. [37]

    Ole Jorgensen, Dylan Cope, Nandi Schoots, and Murray Shanahan. 2023. Improv- ing activation steering in language models with mean-centring. arXiv preprint arXiv:2312.03813 (2023)

    2023 arXiv

  30. [38]

    René Just, Darioush Jalali, and Michael D Ernst. 2014. Defects4J: A database of ex- isting faults to enable controlled testing studies for Java programs. InProceedings of the 2014 international symposium on software testing and analysis . 437–440

    2014

  31. [39]

    Prannay Khosla, Piotr Teterwak, et al . 2020. Supervised contrastive learning. Advances in neural information processing systems 33 (2020), 18661–18673

    2020

  32. [40]

    Bonan Kou, Shengmai Chen, Zhijie Wang, Lei Ma, and Tianyi Zhang. 2024. Do large language models pay similar attention like human programmers when generating code? Proceedings of the ACM on Software Engineering 1, FSE (2024), 2261–2284. FSE Companion ’25, June 23–28, 2025, Tron...

    2024

  33. [41]

    Walter Laurito, Sharan Maiya, Grégoire Dhimoïla, Owen Ho Wan Yeung, and Kaarel Hänni. 2024. Cluster-Norm for Unsupervised Probing of Knowledge. In Proceedings of the 2024 Conference on Empirical Methods in Natural Lan- guage Processing, Yaser Al-Onaizan, Mohit Bansal, and Yun-...

    2024 doi

  34. [42]

    Jia Li et al. 2023. Skcoder: A sketch-based approach for automatic code generation. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) . IEEE, 2124–2135

    2023

  35. [43]

    Jia Li, Yunfei Zhao, Yongmin Li, Ge Li, and Zhi Jin. 2024. Acecoder: An effec- tive prompting technique specialized in code generation. ACM Transactions on Software Engineering and Methodology 33, 8 (2024), 1–26

    2024

  36. [44]

    Kaixin Li, Qisheng Hu, James Zhao, Hui Chen, Yuxi Xie, Tiedong Liu, Michael Shieh, and Junxian He. 2024. Instructcoder: Instruction tuning large language models for code editing. In Proceedings of the 62nd Annual Meeting of the As- sociation for Computational Linguistics (Volu...

    2024

  37. [45]

    Raymond Li, Loubna Ben Allal, Yangtian Zi, et al . 2023. StarCoder: may the source be with you! Transactions on Machine Learning Research (2023). https: //openreview.net/forum?id=KoFOg41haE Reproducibility Certification

    2023

  38. [46]

    Derrick Lin, James Koppel, Angela Chen, and Armando Solar-Lezama. 2017. QuixBugs: A multi-lingual program repair benchmark set based on the Quixey Challenge. In Proceedings Companion of the 2017 ACM SIGPLAN international conference on systems, programming, languages, and appli...

    2017

  39. [47]

    Tie-Yan Liu et al. 2009. Learning to rank for information retrieval. Foundations and Trends® in Information Retrieval 3, 3 (2009), 225–331

    2009

  40. [48]

    Xiangyan Liu, Bo Lan, Zhiyuan Hu, et al . 2024. Codexgraph: Bridging large language models and code repositories via code graph databases. arXiv preprint arXiv:2408.03910 (2024)

    2024 arXiv

  41. [49]

    Yue Liu, Thanh Le-Cong, et al. 2023. Refining ChatGPT-Generated Code: Char- acterizing and Mitigating Code Quality Issues. ACM Transactions on Software Engineering and Methodology (2023)

    2023

  42. [50]

    Yi Liu, Junzhe Yu, Huijia Sun, Ling Shi, Gelei Deng, Yuqi Chen, and Yang Liu. 2024. Efficient Detection of Toxic Prompts in Large Language Models. InProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering . 455–467

    2024

  43. [51]

    Zhijie Liu, Yutian Tang, Xiapu Luo, Yuming Zhou, and Liang Feng Zhang. 2024. No need to lift a finger anymore? Assessing the quality of code generation by ChatGPT. IEEE Transactions on Software Engineering (2024)

    2024

  44. [52]

    Anton Lozhkov, Raymond Li, Loubna Ben Allal, et al. 2024. Starcoder 2 and the stack v2: The next generation. arXiv preprint arXiv:2402.19173 (2024)

    2024 arXiv

  45. [53]

    Samuel Marks and Max Tegmark. 2023. The geometry of truth: Emergent linear structure in large language model representations of true/false datasets. arXiv preprint arXiv:2310.06824 (2023)

    2023 arXiv

  46. [54]

    Samuel Marks and Max Tegmark. 2024. The Geometry of Truth: Emergent Linear Structure in Large Language Model Representations of True/False Datasets. In First Conference on Language Modeling . https://openreview.net/forum?id= aajyHYjjsk

    2024

  47. [55]

    Alexandria Meyer, Jennifer N Bress, and Greg Hajcak Proudfit. 2014. Psycho- metric properties of the error-related negativity in children and adolescents. Psychophysiology 51, 7 (2014), 602–610

    2014

  48. [56]

    Gavin Mischler, Yinghao Aaron Li, Stephan Bickel, Ashesh D Mehta, and Nima Mesgarani. 2024. Contextual feature extraction hierarchies converge in large language models and the brain. Nature Machine Intelligence (2024), 1–11

    2024

  49. [57]

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

    2023 arXiv

  50. [58]

    Andrew Ng et al. 2011. Sparse autoencoder. CS294A Lecture notes 72, 2011 (2011), 1–19

    2011

  51. [59]

    Nhan Nguyen and Sarah Nadi. 2022. An empirical evaluation of GitHub copilot’s code suggestions. In Proceedings of the 19th International Conference on Mining Software Repositories. 1–5

    2022

  52. [60]

    Rangeet Pan, Ali Reza Ibrahimzada, et al. 2024. Lost in translation: A study of bugs introduced by large language models while translating code. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering . 1–13

    2024

  53. [61]

    Rangeet Pan, Ali Reza Ibrahimzada, Rahul Krishna, Divya Sankar, Lam- bert Pouguem Wassi, Michele Merler, Boris Sobolev, Raju Pavuluri, Saurabh Sinha, and Reyhaneh Jabbarvand. 2024. Lost in translation: A study of bugs introduced by large language models while translating code....

    2024

  54. [62]

    Hammond Pearce, Baleegh Ahmad, Benjamin Tan, Brendan Dolan-Gavitt, and Ramesh Karri. 2022. Asleep at the keyboard? assessing the security of github copilot’s code contributions. InIEEE Symposium on Security and Privacy. 754–768

    2022

  55. [63]

    Huy N Phan, Hoang N Phan, Tien N Nguyen, and Nghi DQ Bui. 2024. Repohyper: Better context retrieval is all you need for repository-level code completion.arXiv preprint arXiv:2403.06095 (2024)

    2024 arXiv

  56. [64]

    Przemysław Pobrotyn and Radosław Białobrzeski. 2021. Neuralndcg: Direct optimisation of a ranking metric via differentiable relaxation of sorting. arXiv preprint arXiv:2102.07831 (2021)

    2021 arXiv

  57. [65]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, et al. 2023. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950 (2023)

    2023 arXiv

  58. [66]

    Da Song, Xuan Xie, Jiayang Song, Derui Zhu, Yuheng Huang, Felix Juefei-Xu, and Lei Ma. 2024. LUNA: A Model-Based Universal Analysis Framework for Large Language Models. IEEE Transactions on Software Engineering (2024)

    2024

  59. [67]

    Claudio Spiess, David Gros, et al. 2025. Calibration and correctness of language models for code. Proceedings of the 47th International Conference on Software Engineering (ICSE 2025) (2025)

    2025

  60. [68]

    Hongjin Su, Shuyang Jiang, Yuhang Lai, Haoyuan Wu, Boao Shi, Che Liu, Qian Liu, and Tao Yu. 2024. EvoR: Evolving Retrieval for Code Generation. InFindings of the Association for Computational Linguistics: EMNLP 2024 , Yaser Al-Onaizan, Mohit Bansal, and Yun-Nung Chen (Eds.). A...

    2024 doi

  61. [69]

    Zian Su, Xiangzhe Xu, Ziyang Huang, Zhuo Zhang, Yapeng Ye, Jianjun Huang, and Xiangyu Zhang. 2024. Codeart: Better code models by attention regularization when symbols are lacking. Proceedings of the ACM on Software Engineering 1, FSE (2024), 562–585

    2024

  62. [70]

    Ningzhi Tang, Meng Chen, Zheng Ning, Aakash Bansal, Yu Huang, Collin McMil- lan, and Toby Jia-Jun Li. 2024. A Study on Developer Behaviors for Validating and Repairing LLM-Generated Code Using Eye Tracking and IDE Actions. arXiv preprint arXiv:2405.16081 (2024)

    2024 arXiv

  63. [71]

    CodeGemma Team, Heri Zhao, Jeffrey Hui, Joshua Howland, et al . 2024. Codegemma: Open code models based on gemma.arXiv preprint arXiv:2406.11409 (2024)

    2024 arXiv

  64. [72]

    Runchu Tian, Yining Ye, Yujia Qin, Xin Cong, Yankai Lin, Zhiyuan Liu, and Maosong Sun. 2024. DebugBench: Evaluating Debugging Capability of Large Language Models. arXiv:2401.04621 [cs.SE]

    2024 arXiv

  65. [73]

    A Vaswani. 2017. Attention is all you need. Advances in Neural Information Processing Systems (2017)

    2017

  66. [74]

    Wenhan Wang, Chenyuan Yang, Zhijie Wang, Yuheng Huang, Zhaoyang Chu, Da Song, Lingming Zhang, An Ran Chen, and Lei Ma. 2024. TESTEVAL: Bench- marking Large Language Models for Test Case Generation. arXiv preprint arXiv:2406.04531 (2024)

    2024 arXiv

  67. [75]

    Xingyao Wang, Yangyi Chen, Lifan Yuan, Yizhe Zhang, Yunzhu Li, Hao Peng, and Heng Ji. 2024. Executable Code Actions Elicit Better LLM Agents. In ICML. arXiv:2402.01030

    2024 arXiv

  68. [76]

    Zhijie Wang, Yuheng Huang, Da Song, Lei Ma, and Tianyi Zhang. 2023. Deepseer: Interactive rnn explanation and debugging via state abstraction. In Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems . 1–20

    2023

  69. [77]

    Zhijie Wang, Zijie Zhou, Da Song, Yuheng Huang, Shengmai Chen, Lei Ma, and Tianyi Zhang. 2024. Where Do Large Language Models Fail When Generating Code? arXiv preprint arXiv:2406.08731 (2024)

    2024 arXiv

  70. [78]

    Yuxiang Wei, Zhe Wang, Jiawei Liu, Yifeng Ding, and Lingming Zhang. 2024. Magicoder: Empowering Code Generation with OSS-Instruct. In Proceedings of the 41st International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 235). PMLR, 52632–52657. h...

    2024

  71. [79]

    Xinwei Wu, Weilong Dong, Shaoyang Xu, and Deyi Xiong. 2024. Mitigat- ing Privacy Seesaw in Large Language Models: Augmented Privacy Neuron Editing via Activation Patching. In Findings of the Association for Computa- tional Linguistics: ACL 2024 , Lun-Wei Ku, Andre Martins, and...

    2024 doi

  72. [80]

    Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. 2023. Automated program repair in the era of large pre-trained language models. In2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) . IEEE, 1482–1494

    2023

  73. [81]

    Danning Xie, Zhuo Zhang, Nan Jiang, Xiangzhe Xu, Lin Tan, and Xiangyu Zhang

  74. [82]

    Zhaojian Yu, Xin Zhang, et al . 2024. WaveCoder: Widespread and versatile enhancement for code large language models by instruction tuning. In Proceed- ings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 5140–5153

    2024

  75. [83]

    In Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security

    ReSym: Harnessing LLMs to Recover Variable and Data Structure Symbols from Stripped Binaries. In Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security . 4554–4568

    2024

  76. [84]

    Andy Zou, Long Phan, Sarah Chen, James Campbell, Phillip Guo, Richard Ren, Alexander Pan, Xuwang Yin, Mantas Mazeika, Ann-Kathrin Dombrowski, et al

  77. [85]

    Shaolei Zhang, Tian Yu, and Yang Feng. 2024. TruthX: Alleviating Hallucinations by Editing Large Language Models in Truthful Space. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), Lun-Wei Ku, Andre Martins, an...

    2024

  78. [2023]

    arXiv preprint arXiv:2310.01405 (2023)

    Representation engineering: A top-down approach to ai transparency. arXiv preprint arXiv:2310.01405 (2023)

    2023 arXiv

  79. [2024]

    arXiv preprint arXiv:2406.14144 (2024)

    Finding Safety Neurons in Large Language Models. arXiv preprint arXiv:2406.14144 (2024)

    2024

Pith tools

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