Pith. sign in

REVIEW 4 major objections 6 minor 65 references

How Reasoning Shapes Social Bias in LLM-Generated Code?

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

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

Pith's one-line read Reasoning reduces social bias in LLM-generated code, and rewriting biased reasoning traces cuts bias by 83.7% while keeping code quality.

desk verdict The first study of bias in reasoning-based code generation has a promising probe-based detector, but its headline 'reasoning reduces bias' is threatened by a quality-collapse confound. read the letter →

arxiv 2608.06829 v1 pith:YKK2FN6R submitted 2026-08-07 cs.SE

Weifeng Sun , Jieke Shi , Zhou Yang , Yuchen Chen , Hongyan Li , Meng Yan , David Lo This is my paper · ORCID
classification cs.SE
keywords socialbiascodegenerationreasoningtraceslargemodelschain-of-thoughtmitigationfairnessLLM-as-a-judge
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

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

The reading

This paper asks whether the intermediate reasoning traces that large models produce before writing code make the final code more or less socially biased. Across nine models and three decision scenarios (hiring, college admission, medical treatment), it finds that reasoning lowers the average code-bias rate from 0.64 to 0.40, but the gain is model-dependent and code quality drops from 0.72 to 0.59 on average. It also finds that biased reasoning strongly predicts biased code, while unbiased reasoning does not guarantee fair code. The central contribution is ProbeDebias, which detects biased reasoning traces by measuring how easily the target model predicts a bias-indicative probe sentence, removes the bias from the trace, and regenerates the code; this reduces code bias by 83.73% (0.56 to 0.09) with essentially no quality loss. If correct, the result establishes the reasoning stage as a practical and efficient intervention point for making LLM-generated code fairer.

What carries the argument

The load-bearing mechanism is the probe-based detector: for each reasoning trace, the paper appends the fixed sentence "Note that this reasoning contains bias based on sensitive attributes." and measures the target model's token-level prediction loss over that sentence. A biased trace makes the probe easy to predict (low loss); an unbiased trace makes it surprising (high loss). A small LoRA adapter is trained on labeled traces to clamp this loss into a binary bias score, thresholded by Youden's J for classification. The second component rewrites flagged traces with an LLM under three constraints — remove sensitive-attribute decisions, preserve task-relevant evidence, and condense the trace — then feeds the debiased trace into the target model's thinking block before code generation.

What would settle it

Collect a test set of reasoning traces where the sensitive attribute is never mentioned but the reasoning relies on a proxy (e.g., neighborhood standing in for race), have human annotators label them, and compare human labels to GPT-5.1 and to ProbeDebias. If the probe detector's F1 falls materially below the reported 87.76% when judged against humans on these proxy-bias cases, the core claim that biased reasoning is detectable and rewritable before code generation is falsified for exactly the hard cases that matter.

Watch

Extended reading notes

Core claim

The paper's central claim is that social bias in code is not merely a property of the final program but is shaped at the reasoning stage, and that intervening there is the most effective lever. Empirically it claims: (1) reasoning reduces bias prevalence by making biased code rarer rather than by softening the bias that occurs; (2) bias propagates from reasoning traces to code in a substantial share of cases, and the propagation is strongest in high-stakes medical scenarios; (3) generation-configuration tweaks (longer reasoning, higher temperature, attribute position) help standard LLMs only at a quality cost and barely move native-reasoning models; and (4) ProbeDebias, by detecting traces with a probe-loss signal and rewriting them, cuts average code bias from 0.56 to 0.09 and improves fairness score from 0.37 to 0.85 while keeping quality at 0.76 versus 0.77.

Load-bearing premise

The load-bearing assumption is that the GPT-5.1 labels for which reasoning traces are biased are accurate enough to stand in for human judgment: the paper validates them on only 216 of roughly 136,000 traces, with 81.94% agreement, and every downstream result — propagation rates, detector F1, and mitigation gain — inherits those labels.

Editorial extensions

If this is right

  • Reasoning-stage analysis becomes a viable path for trustworthy code generation: detecting bias before code is written can outperform prompt-only mitigation.
  • The fairness-quality trade-off of reasoning means that simply enabling CoT or using reasoning models is not a reliable mitigation strategy.
  • Because unbiased reasoning still produces biased code, code-level checks remain necessary even with reasoning.
  • The fact that a 30.94 MB LoRA adapter beats full fine-tuned classifiers suggests bias detection can be deployed cheaply at inference time.
  • Configuration tuning is a weak lever: for standard LLMs it trades quality for bias, and for LRMs it leaves both mostly unchanged.

Reading between the lines

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

  • The probe-loss signal is not intrinsically about fairness: it measures how fluently a model continues a claim about a trace. The same trick may transfer to detecting security or privacy risks in reasoning traces, or other properties the model 'knows' about its own output, though ProbeDebias does not test this.
  • Because FairCoder's static scorer only catches explicit score adjustments on sensitive attributes, the reported bias rates likely undercount implicit or proxy bias (e.g., a feature correlated with race). A version of the study scored on correlated-proxy features could show a smaller benefit from reasoning.
  • The detector is trained on GPT-5.1 labels; if the judge's notion of bias drifts with future model versions, the reported F1 is a ceiling relative to human judgment. Keeping a human-validated seed set for continual calibration would be the natural follow-up.
  • The rewriting model (Qwen3-Max) is proprietary; if it is swapped for an open model, the 83.73% reduction is a target to re-measure rather than a guarantee.
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

4 major / 6 minor

Summary. The paper presents the first systematic study of social bias in reasoning-based code generation. It evaluates 9 LLMs/LRMs on three FairCoder tasks (job hiring, college admission, medical treatment) under both direct (Vanilla) and reasoning-based generation, measuring Bias Rate, Preference Entropy, Fairness Score, and PyLint quality. The main empirical findings are that reasoning lowers the average bias rate from 0.64 to 0.40 but degrades code quality from 0.72 to 0.59; that biased reasoning traces are strongly associated with biased code; and that generation-configuration changes have limited and model-dependent effects. The paper then proposes ProbeDebias, a two-component framework that detects biased reasoning traces with a probe-based LoRA detector and rewrites them before code generation, reporting 87.76% F1 for detection and an 83.73% relative reduction in code bias with near-zero quality loss. The paper includes a cross-model split for detector evaluation, an ablation study, and a small external-benchmark generalization check.

Significance. If the findings are robust, this is a valuable and timely contribution: it identifies the reasoning stage as a new intervention point for fairness in LLM-generated code, and it offers a lightweight, practical mitigation technique. The paper ships a replication package, uses paired Wilcoxon tests with Cliff's delta for RQ1, uses a cross-model split for detector evaluation, and attempts an external-benchmark generalization check, all of which are strengths. However, the headline bias-reduction claims are currently threatened by a quantity-versus-quality confound (broken code may be trivially counted as unbiased) and by dependence on LLM-generated ground-truth labels for reasoning bias. These issues directly affect RQ1 and RQ4 conclusions, so the significance of the paper depends on the revision addressing them convincingly.

major comments (4)
  1. [§3.6, Tables 2-4, §6] The bias-rate metric is computed by get_score, which only detects score-update rules inside decision conditions. The paper reports dramatic bias-rate reductions in exactly the models that suffer severe PyLint quality collapse (e.g., CodeLlama-7B BR 0.78→0.21 with quality 0.47→0.14; Llama2-13B BR 0.80→0.18 with quality 0.80→0.27; Qwen3-32B BR 0.56→0.07 with quality 0.83→0.47). Because the paper applies no validity filter (no syntax check, no completeness check), a program that is syntactically invalid, truncated, or missing its function body will contain no score-update rules and will be counted as unbiased by construction. This confound directly undermines Findings 1 and 10 and the abstract's claims of 0.64→0.40 and 83.73% reduction. The threats-to-validity section does not mention this quantity-versus-quality confound. The authors must re-run the analyses after filtering to valid, executable programs, and report whether the bias reductions persist on that subset.
  2. [§4.2.2, §4.4.4, §6] The reasoning-bias labels that drive RQ2 and the ProbeDebias detector training/evaluation are produced by GPT-5.1, with manual validation on only 216 of roughly 136,000 traces (81.94% accuracy, 84.71% F1). This means the RQ2 propagation rates and the detector's reported 87.76% F1 are, in large part, measures of agreement with GPT-5.1 rather than with human ground truth. If GPT-5.1 systematically misjudges what counts as biased reasoning (e.g., over-flagging fairness language or missing implicit stereotypes), the propagation findings and the mitigation results inherit that error. The paper acknowledges this in Section 6 but does not quantify the sensitivity. The authors should provide per-category agreement, error analysis, and ideally a larger human-validated set; at minimum, a bootstrap or label-noise sensitivity analysis should show that the key RQ2 and RQ4 conclusions are stable.
  3. [Table 6, §4.4.4] The mitigation results that support the central RQ4 claim are reported as single point estimates with no variance, confidence intervals, or significance tests. The claim that ProbeDebias reduces BR from 0.56 to 0.09 (83.73% relative reduction) rests on five per-model numbers with no repeated-run variation or statistical comparison against the BMcot and BMfew-shot baselines. Given that ProbeDebias is the main methodological contribution, the authors should report standard deviations over repeated runs (or bootstrap intervals) and, where possible, pairwise significance tests for the aggregate comparisons.
  4. [§4.3, Figures 5-7] The RQ3 configuration findings are based on a single standard LLM and a single LRM, with no error bars or significance tests. For example, the conclusion that longer reasoning reduces bias for Llama-3.1-8B from 0.56 to 0.35 is presented as one curve without confidence intervals, and the claim that Qwen3-8B is 'largely stable' rests on visual inspection of small fluctuations. Since this section feeds into the conclusion that configuration tuning is insufficient for mitigation, the authors should add at least confidence intervals or replicate each configuration setting multiple times to establish that the observed trends are not noise.
minor comments (6)
  1. [§3.5] The list of evaluated standard LLMs does not include Llama2-13B or Qwen3-14B, yet these models appear in Tables 2-4 and in the RQ2 discussion; please clarify the model categorization and ensure the 9-model list is complete and consistent.
  2. [§2.1 and References] The text cites 'Ling et al. [28]' for Solar, but the bibliography lists [28] as Lin Ling's companion paper 'Evaluating social bias in code generation models' and [29] as 'Bias unveiled' by Ling et al.; this citation appears to be inconsistent and should be corrected.
  3. [§3.6, Equation (2)] Equation (2) is unclear for the all-zero score vector: the text says the transformation produces a uniform distribution, but the formula with min(S) ≤ 0 and epsilon is not specified for the case where all scores are zero; please state the special case explicitly.
  4. [Table 6] In the Average row for BM cot, the value '0.930.76' appears to be a formatting error; it should read '0.93' and '0.76' with a separator, as in other rows.
  5. [Figure 4] The flow percentages are given without error bars or confidence intervals, and the bar counts for each category are not shown; adding the underlying counts and uncertainty would strengthen the propagation claim.
  6. [§4.4.2] The probe detector depends on several hyperparameters (β, λ, LoRA rank r/α, and the threshold τ selected via Youden's J), but no sensitivity analysis is reported; at least a brief robustness check on τ and λ would help establish that the detector's F1 is not a narrow peak.

Circularity Check

2 steps flagged · score 6.0 of 10

Partial circularity: ProbeDebias's 87.76% F1 is agreement with GPT-5.1 labels, and RQ1's bias-rate drop is definitionally inflated because get_score treats rule-free/broken code as unbiased.

  1. self definitional [Section 3.6, Eq. (1); Tables 2 and 4]
    "A generated program is considered biased if the subgroup scores returned by 𝑔𝑒𝑡_𝑠𝑐𝑜𝑟𝑒(·) are not identical across all groups. ... 𝑔𝑒𝑡_𝑠𝑐𝑜𝑟𝑒(·) first checks whether 𝑎 appears in a decision condition (e.g., if gender == "male") that directly alters the decision logic via score-update statements such as score += k or score -= k."

    By Eq. (1), any generated program in which 𝑔𝑒𝑡_𝑠𝑐𝑜𝑟𝑒 finds no score-update decision rule has identical (zero) scores for every subgroup and is automatically counted as unbiased. The paper applies no validity filter, and Tables 2 and 4 show the largest BR drops under reasoning coincide with PyLint collapses (CodeLlama-7B quality 0.47→0.14, Llama2-13B 0.80→0.27, Qwen3-32B 0.83→0.47). The average reduction from 0.64 to 0.40 (and FS 0.30→0.51) is therefore partly a definitional consequence of reasoning producing broken or rule-free code, not solely evidence of fairer decision logic.

  2. fitted input called prediction [Sections 4.2.2 and 4.4.3; Table 5; Section 6]
    "For reasoning bias, we adopt an LLM-as-a-Judge protocol [62] ... Specifically, we use OpenAI GPT-5.1 to determine whether a reasoning trace is biased or unbiased. ... To train the probe-based bias detector, we reuse the labeled dataset constructed in RQ2, where each reasoning trace is annotated as biased or unbiased."

    The probe detector is trained and evaluated on the GPT-5.1-labeled RQ2 dataset, so its reported 87.76% F1 measures agreement with GPT-5.1's bias judgments, not bias against an independent ground truth. Section 6 explicitly admits "potential circularity in using one LLM to judge another LLM's bias"; the 216-pair human validation (81.94% accuracy) is the only external anchor and is not the test set for the headline F1. Thus the "reasoning-bias detection" claim partially reduces to predicting the judge's own labels.

full rationale

The paper is an empirical study, not a formal derivation, and its external-benchmark check (Section 5.2) and manual label validation (Section 6) provide some independent evidence, so this is not wholesale circularity. No load-bearing self-citation chain is present. However, two central quantities are partially self-referential. First, the RQ1 bias reduction is measured by FairCoder's get_score, which by definition counts programs without detectable score-update rules as unbiased, while reasoning simultaneously collapses PyLint quality for the very models with the largest BR drops; the paper reports the quality trade-off but does not filter or adjust for this mechanical effect. Second, the ProbeDebias detector's headline F1 is computed against GPT-5.1's own labels, which the paper itself flags as potentially circular; the detector is trained on those same labels and its evaluation set is drawn from the same label source. These issues make the headline bias-reduction and detection numbers partly artifacts of the chosen definitions and labeling protocol, warranting a score of 6 rather than 0-2.

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

The core empirical claims rest on standard statistical tests (Wilcoxon) and on domain assumptions about how bias and quality are measured. The strongest assumptions are that explicit score adjustments capture code bias, that GPT-5.1 labels for reasoning bias are reliable enough to serve as ground truth, and that PyLint is a meaningful quality proxy. The ProbeDebias framework adds several free hyperparameters (beta, lambda, LoRA rank and alpha, threshold tau) that are tuned on validation data.

free parameters (4)
  • beta (probe score sharpness) = not reported
    Controls the mapping from probe loss to bias score in Eq. (6); chosen by hand, not justified.
  • lambda (SFT balancing coefficient) = not reported
    Balances probe loss and next-token loss in Eq. (7); chosen by hand.
  • LoRA rank r and alpha = r=8, alpha=32
    Adapter hyperparameters for the probe detector; reported in Section 4.4.3 but not tuned systematically.
  • detection threshold tau = selected via Youden's J on validation set
    The classifier threshold is fit to the validation set, so the 87.76% F1 is on the test set after threshold fitting.
assumptions (4)
  • domain assumption Code bias is fully captured by explicit score adjustments on sensitive attributes in decision logic (get_score static analysis).
    Section 3.6; the paper acknowledges in Section 6 that this misses implicit or proxy bias, so the measured bias rate is a lower bound.
  • domain assumption GPT-5.1 bias judgments on reasoning traces are reliable enough to serve as ground truth.
    Section 4.2.2; only 216 pairs manually validated with 81.94% accuracy, so the labels inherit the judge's errors.
  • domain assumption PyLint score is a valid proxy for code quality in these bias-sensitive tasks.
    Section 3.6; no functional test suites exist for these tasks, and static lint quality may not reflect semantic correctness.
  • standard math Wilcoxon signed-rank test and Cliff's delta are appropriate for comparing paired model outputs.
    Section 4.1.3; standard non-parametric tests for paired samples.

how reviews work

0 comments
Cite this review

Pith. "Pith review of How Reasoning Shapes Social Bias in LLM-Generated Code?." pith.science (2026). https://pith.science/paper/YKK2FN6R

@misc{pith2026260806829,
  author       = {Pith},
  title        = {Pith review of: How Reasoning Shapes Social Bias in LLM-Generated Code?},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YKK2FN6R}},
  note         = {Machine review of arXiv:2608.06829}
}
read the original abstract

Large language models (LLMs) are increasingly used for code generation, yet generated programs may exhibit social bias through unfair or differential treatment of sensitive demographic attributes. While prior work mainly studies direct code generation, bias in reasoning-based generation remains underexplored. We conduct the first systematic study of social bias in reasoning-based code generation, evaluating 9 standard LLMs and large reasoning models (LRMs) on realistic bias-sensitive tasks across three human-centered decision scenarios. We find that reasoning generally reduces bias, lowering the average bias rate from 0.64 to 0.40, but the effect varies substantially across models. Meanwhile, code quality is not consistently preserved, with the average quality dropping from 0.72 to 0.59. Biased reasoning strongly predicts biased code, and adjusting generation configurations alone is insufficient for robust mitigation. Based on these findings, we propose ProbeDebias, a reasoning-aware framework that detects and rewrites biased reasoning traces before code generation. ProbeDebias achieves 87.76% F1 for reasoning-bias detection and reduces code bias by 83.73% on average while largely preserving quality. Compared with SOTA baselines, it further reduces average bias by 52.70%-54.42% and improves quality by 9.79%-36.79%. These results highlight the value of reasoning-stage analysis for trustworthy code generation.

Figures

Figures reproduced from arXiv: 2608.06829 by the authors.

Figure 1
Figure 1. Prior work vs. our problem setting. al. [9] introduce FairCoder, a benchmark that assesses bias in code￾related tasks spanning both function implementation and unit test generation. Ling et al. [29] further develop Solar, an automated framework that uses generated test cases to uncover social bias in synthesized code. Despite differences in evaluation design, such studies mainly examine bias in standard LLMs operati… view at source ↗
Figure 2
Figure 2. Illustration of biased and unbiased code. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Overall study framework for analyzing and mitigating social bias in reasoning-based code generation. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Relationship between bias in model reasoning and [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Effect of reasoning length on social bias. [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Effect of sampling temperature on social bias. [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]
Figure 8
Figure 8. Figure 8: Overview of ProbeDebias. adapter, and (2) a reasoning rewriting module that converts biased reasoning into an unbiased form and guides the code generation. ❶ Component 1: Probe-Based Bias Detector. To mitigate code bias, we detect biased reasoning traces before code ge…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

65 extracted references · 27 canonical work pages

  1. [1]

    https://www.bls.gov/cps/

    2025. https://www.bls.gov/cps/

    work page 2025

  2. [2]

    https://nces.ed.gov/programs/digest/d22/

    2025. https://nces.ed.gov/programs/digest/d22/

    work page 2025

  3. [3]

    Marah Abdin, Sahaj Agarwal, Ahmed Awadallah, Vidhisha Balachandran, Harki- rat Behl, Lingjiao Chen, Gustavo de Rosa, Suriya Gunasekar, Mojan Java- heripi, Neel Joshi, et al. 2025. Phi-4-reasoning technical report.arXiv preprint arXiv:2504.21318(2025)

    arXiv 2025

  4. [4]

    Soumya Barikeri, Anne Lauscher, Ivan Vulić, and Goran Glavaš. 2021. Reddit- Bias: A real-world resource for bias evaluation and debiasing of conversational language models. InProceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Pap...

    work page 2021

  5. [5]

    Tuan-Dung Bui, Thanh Trong Vu, Thu-Trang Nguyen, Son Nguyen, and Hieu Dinh Vo. 2025. Correctness assessment of code generated by Large Lan- guage Models using internal representations.Journal of Systems and Software (2025), 112570

    work page 2025

  6. [6]

    Norman Cliff. 1993. Dominance statistics: Ordinal analyses to answer ordinal questions.Psychological bulletin114, 3 (1993), 494

    1993

  7. [7]

    Sam Corbett-Davies, Emma Pierson, Avi Feller, Sharad Goel, and Aziz Huq. 2017. Algorithmic decision making and the cost of fairness. InProceedings of the 23rd acm sigkdd international conference on knowledge discovery and data mining. 797–806

    2017

  8. [8]

    Xueying Du, Mingwei Liu, Kaixin Wang, Hanlin Wang, Junwei Liu, Yixuan Chen, Jiayi Feng, Chaofeng Sha, Xin Peng, and Yiling Lou. 2024. Evaluating large language models in class-level code generation. InProceedings of the IEEE/ACM 46th International Conference on Software Engineering. 1–13

    2024

Show all 65 references
  1. [9]

    Yongkang Du, Jen-tse Huang, Jieyu Zhao, and Lu Lin. 2025. Faircoder: Evaluating social bias of llms in code generation.arXiv preprint arXiv:2501.05396(2025)

    2025 arXiv

  2. [10]

    Virginia Felkner, Ho-Chun Herbert Chang, Eugene Jang, and Jonathan May. 2023. Winoqueer: A community-in-the-loop benchmark for anti-lgbtq+ bias in large language models. InProceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long P...

    2023

  3. [11]

    Eve Fleisig and Christiane Fellbaum. 2022. Mitigating gender bias in machine translation through adversarial learning.arXiv preprint arXiv:2203.10675(2022)

    2022 arXiv

  4. [12]

    Yujia Fu, Peng Liang, Amjed Tahir, Zengyang Li, Mojtaba Shahin, Jiaxin Yu, and Jinfu Chen. 2025. Security weaknesses of copilot-generated code in github projects: An empirical study.ACM Transactions on Software Engineering and Methodology34, 8 (2025), 1–34

    2025

  5. [13]

    Sainyam Galhotra, Yuriy Brun, and Alexandra Meliou. 2017. Fairness testing: testing software for discrimination. InProceedings of the 2017 11th Joint meeting on foundations of software engineering. 498–510

    2017

  6. [14]

    Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. 2024. The llama 3 herd of models.arXiv preprint arXiv:2407.21783 (2024)

    2024 arXiv

  7. [15]

    Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, et al. 2025. Deepseek-r1: Incen- tivizing reasoning capability in llms via reinforcement learning.arXiv preprint arXiv:2501.12948(2025)

    2025 arXiv

  8. [16]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yifan Wu, YK Li, et al. 2024. DeepSeek-Coder: when the large language model meets programming–the rise of code intelligence.arXiv preprint arXiv:2401.14196(2024)

    2024 arXiv

  9. [17]

    Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Liang Wang, Weizhu Chen, et al. 2022. Lora: Low-rank adaptation of large language models.Iclr1, 2 (2022), 3

    2022

  10. [18]

    Zhang, Qingwen Bu, Xiaofei Xie, Junjie Chen, and Heming Cui

    Dong Huang, Jie M. Zhang, Qingwen Bu, Xiaofei Xie, Junjie Chen, and Heming Cui. 2025. Bias testing and mitigation in llm-based code generation.ACM Transactions on Software Engineering and Methodology35, 1 (2025), 1–31

    2025

  11. [19]

    Yue Huang, Lichao Sun, Haoran Wang, Siyuan Wu, Qihui Zhang, Yuan Li, Chujie Gao, Yixin Huang, Wenhan Lyu, Yixuan Zhang, et al. 2024. Position: Trustllm: Trustworthiness in large language models. InInternational Conference on Machine Learning. PMLR, 20166–20270

    2024

  12. [20]

    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)

    2024 arXiv

  13. [21]

    Alexander I Iliev, Deepshikha Singh, and Sanjeeth Chittyala. 2025. Bias Detection and Mitigation in Large Language Models for Code Generation.IEEE Internet of Things Journal(2025)

    2025

  14. [22]

    Juyong Jiang, Fan Wang, Jiasi Shen, Sungju Kim, and Sunghun Kim. 2026. A survey on large language models for code generation.ACM Transactions on Software Engineering and Methodology35, 2 (2026), 1–72

    2026

  15. [23]

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

    2023 arXiv

  16. [24]

    Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. 2022. Large language models are zero-shot reasoners.Advances in neural information processing systems35 (2022), 22199–22213

    2022

  17. [25]

    Rrezarta Krasniqi, Depeng Xu, and Marco Vieira. 2025. SE Perspective on LLMs: Biases in Code Generation, Code Interpretability, and Code Security Risks.Com- put. Surveys58, 5 (2025), 1–16

    2025

  18. [26]

    Hwaran Lee, Seokhee Hong, Joonsuk Park, Takyoung Kim, Gunhee Kim, and Jung-Woo Ha. 2023. KoSBI: A dataset for mitigating social bias risks towards safer large language model applications. InProceedings of the 61st Annual Meeting of the Association for Computational Linguistics...

    2023

  19. [27]

    Jia Li, Ge Li, Yongmin Li, and Zhi Jin. 2025. Structured chain-of-thought prompt- ing for code generation.ACM Transactions on Software Engineering and Method- ology34, 2 (2025), 1–23

    2025

  20. [28]

    Lin Ling. 2024. Evaluating social bias in code generation models. InCompan- ion Proceedings of the 32nd ACM International Conference on the Foundations of Software Engineering. 695–697

    2024

  21. [29]

    Lin Ling, Fazle Rabbi, Song Wang, and Jinqiu Yang. 2025. Bias unveiled: Investi- gating social bias in LLM-generated code. InProceedings of the AAAI conference on artificial intelligence, Vol. 39. 27491–27499

    2025

  22. [30]

    Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. 2023. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation.Advances in neural information processing systems 36 (2023), 21558–21572

    2023

  23. [31]

    Kang Liu, Yongkang Liu, Xiaocui Yang, Peidong Wang, Wen Zhang, Shi Feng, Yifei Zhang, and Daling Wang. 2026. NEAT: Neuron-Based Early Exit for Large Reasoning Models.arXiv preprint arXiv:2602.02010(2026)

    2026 arXiv

  24. [32]

    Ren-Biao Liu, Anqi Li, Chaoding Yang, Hui Sun, and Ming Li. 2025. Revisit- ing Chain-of-Thought in code generation: Do language models need to learn reasoning before coding?. InForty-second International Conference on Machine Learning

    2025

  25. [33]

    Yan Liu, Xiaokang Chen, Yan Gao, Zhe Su, Fengji Zhang, Daoguang Zan, Jian- Guang Lou, Pin-Yu Chen, and Tsung-Yi Ho. 2023. Uncovering and quantifying social biases in code generation.Advances in Neural Information Processing Systems36 (2023), 2368–2380

    2023

  26. [34]

    Yue Liu, Thanh Le-Cong, Ratnadira Widyasari, Chakkrit Tantithamthavorn, Li Li, Xuan-Bach D Le, and David Lo. 2024. Refining chatgpt-generated code: Characterizing and mitigating code quality issues.ACM Transactions on Software Engineering and Methodology33, 5 (2024), 1–26

    2024

  27. [35]

    Vahid Majdinasab, Michael Joshua Bishop, Shawn Rasheed, Arghavan Moradi- dakhel, Amjed Tahir, and Foutse Khomh. 2024. Assessing the security of github copilot’s generated code-a targeted replication study. In2024 IEEE International Conference on Software Analysis, Evolution an...

    2024

  28. [36]

    S Mouselinos, M Malinowski, and H Michalewski. [n. d.]. A simple, yet effec- tive approach to finding biases in code generation. arXiv 2022.arXiv preprint arXiv:2211.00609([n. d.])

    2022 arXiv

  29. [37]

    Sida Peng, Eirini Kalliamvakou, Peter Cihon, and Mert Demirer. 2023. The impact of ai on developer productivity: Evidence from github copilot.arXiv preprint arXiv:2302.06590(2023)

    2023 arXiv

  30. [38]

    PyCQA. 2025. Pylint Documentation. https://pylint.readthedocs.io/. Accessed 2025-11-09

    2025

  31. [39]

    Zhanyue Qin, Haochuan Wang, Zecheng Wang, Deyuan Liu, Cunhang Fan, Zhao Lv, Zhiying Tu, Dianhui Chu, and Dianbo Sui. 2024. Mitigating gender bias in code large language models via model editing.arXiv preprint arXiv:2410.07820 (2024)

    2024 arXiv

  32. [40]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiao- qing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. 2023. Code llama: Open foundation models for code.arXiv preprint arXiv:2308.12950 (2023)

    2023 arXiv

  33. [41]

    Leonard Salewski, Stephan Alaniz, Isabel Rio-Torto, Eric Schulz, and Zeynep Akata. 2023. In-context impersonation reveals large language models’ strengths and biases.Advances in neural information processing systems36 (2023), 72044– 72057

    2023

  34. [42]

    Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. 2024. Scaling llm test- time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314(2024)

    2024 arXiv

  35. [43]

    Yang Sui, Yu-Neng Chuang, Guanchu Wang, Jiamu Zhang, Tianyi Zhang, Jiayi Yuan, Hongyi Liu, Andrew Wen, Shaochen Zhong, Na Zou, et al . 2025. Stop overthinking: A survey on efficient reasoning for large language models.arXiv preprint arXiv:2503.16419(2025)

    2025 arXiv

  36. [44]

    Weifeng Sun, Naiqi Huang, Meng Yan, Li Huang, Zhongxin Liu, Xiao Liu, and David Lo. 2026. Cost-Effective Adversarial Attacks Against Code LLM with Model Attention.IEEE Transactions on Software Engineering(2026)

    2026

  37. [45]

    Weifeng Sun, Meng Yan, Zhou Yang, Yuchen Chen, Song Sun, and David Lo. 2026. MultiCodeAttack: Iterative Jailbreak Attacking on LLMs with Multi-Code Prompt Injection. InFindings of the Association for Computational Linguistics: ACL 2026. 14670–14690

    2026

  38. [46]

    Himanshu Thakur, Atishay Jain, Praneetha Vaddamanu, Paul Pu Liang, and Louis- Philippe Morency. 2023. Language models get a gender makeover: Mitigating gender bias with few-shot data interventions. InProceedings of the 61st Annual How Reasoning Shapes Social Bias in LLM-Genera...

    2023

  39. [47]

    Eddie Ungless, Amy Rafferty, Hrichika Nag, and Björn Ross. 2022. A robust bias mitigation procedure based on the stereotype content model. InProceedings of the Fifth Workshop on Natural Language Processing and Computational Social Science (NLP+ CSS). 207–217

    2022

  40. [48]

    Peiyi Wang, Lei Li, Liang Chen, Zefan Cai, Dawei Zhu, Binghuai Lin, Yunbo Cao, Lingpeng Kong, Qi Liu, Tianyu Liu, et al. 2024. Large language models are not fair evaluators. InProceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Lo...

    2024

  41. [49]

    Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2022. Self-consistency improves chain of thought reasoning in language models.arXiv preprint arXiv:2203.11171(2022)

    2022 arXiv

  42. [50]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. 2022. Chain-of-thought prompting elicits reasoning in large language models.Advances in neural information processing systems35 (2022), 24824–24837

    2022

  43. [51]

    Xin-Cheng Wen, Zirui Lin, Yijun Yang, Cuiyun Gao, and Deheng Ye. 2025. Vul-R2: A Reasoning LLM for Automated Vulnerability Repair.arXiv preprint arXiv:2510.05480(2025)

    2025

  44. [52]

    Frank Wilcoxon. 1992. Individual comparisons by ranking methods. InBreak- throughs in statistics: Methodology and distribution. Springer, 196–202

    1992

  45. [53]

    An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, et al. 2025. Qwen3 technical report.arXiv preprint arXiv:2505.09388(2025)

    2025 arXiv

  46. [54]

    Guang Yang, Yu Zhou, Xiang Chen, Xiangyu Zhang, Terry Yue Zhuo, and Taolue Chen. 2024. Chain-of-thought in neural code generation: From and for lightweight language models.IEEE Transactions on Software Engineering50, 9 (2024), 2437– 2457

    2024

  47. [55]

    Zezhou Yang, Sirong Chen, Cuiyun Gao, Zhenhao Li, Xing Hu, Kui Liu, and Xin Xia. 2025. An empirical study of retrieval-augmented code generation: Challenges and opportunities.ACM Transactions on Software Engineering and Methodology 34, 7 (2025), 1–28

    2025

  48. [56]

    Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. 2023. Tree of thoughts: Deliberate problem solving with large language models.Advances in neural information processing systems36 (2023), 11809–11822

    2023

  49. [57]

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. InThe eleventh international conference on learning representations

    2022

  50. [58]

    William J Youden. 1950. Index for rating diagnostic tests.Cancer3, 1 (1950), 32–35

    1950

  51. [59]

    Yue Yu, Yuchen Zhuang, Jieyu Zhang, Yu Meng, Alexander J Ratner, Ranjay Krishna, Jiaming Shen, and Chao Zhang. 2023. Large language model as attrib- uted training data generator: A tale of diversity and bias.Advances in neural information processing systems36 (2023), 55734–55784

    2023

  52. [60]

    Daoguang Zan, Bei Chen, Fengji Zhang, Dianjie Lu, Bingchao Wu, Bei Guan, Wang Yongji, and Jian-Guang Lou. 2023. Large language models meet NL2Code: A survey. InProceedings of the 61st Annual Meeting of the Association for Compu- tational Linguistics (Volume 1: Long Papers). 7443–7464

    2023

  53. [61]

    Xiaoyu Zhang, Juan Zhai, Shiqing Ma, Qingshuang Bao, Weipeng Jiang, Qian Wang, Chao Shen, and Yang Liu. 2025. The invisible hand: Unveiling provider bias in large language models for code generation. InProceedings of the 63rd Annual Meeting of the Association for Computational...

    2025

  54. [62]

    Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. 2023. Judging llm-as-a-judge with mt-bench and chatbot arena.Advances in neural information processing systems36 (2023), 46595–46623

    2023

  55. [63]

    Xueyang Zhou, Guiyao Tie, Guowen Zhang, Weidong Wang, Zhigang Zuo, Di Wu, Duanfeng Chu, Pan Zhou, Lichao Sun, and Neil Zhenqiang Gong. 2025. Large reasoning models in agent scenarios: exploring the necessity of reasoning capabilities.arXiv e-prints(2025), arXiv–2503

    2025

  56. [64]

    Yuqi Zhu, Ge Li, Xue Jiang, Jia Li, Hong Mei, Zhi Jin, and Yihong Dong. 2025. Uncertainty-guided chain-of-thought for code generation with llms.arXiv preprint arXiv:2503.15341(2025)

    2025 arXiv

  57. [65]

    Arastoo Zibaeirad and Marco Vieira. 2025. Reasoning with llms for zero-shot vulnerability detection.arXiv preprint arXiv:2503.17885(2025). Received 2026-03-26; accepted 2026-06-18

    2025 arXiv

Pith tools

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