Pith. sign in

REVIEW 5 major objections 5 minor 41 references

CoderAgent: Simulating Student Behavior for Personalized Programming Learning with Large Language Models

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

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

Pith's one-line read CoderAgent simulates students' step-by-step code-fixing behavior—intention, location, and next submission—without large training datasets.

desk verdict A novel agent framework for simulating students' iterative coding process, but the key accuracy claims rest on an unvalidated LLM judge and near-chance outcome predictions. read the letter →

arxiv 2505.20642 v1 pith:FUKIHQOD submitted 2025-05-27 cs.AI

Yi Zhan , Qi Liu , Weibo Gao , Zheng Zhang , Tianfu Wang , Shuanghong Shen , Junyu Lu , Zhenya Huang This is my paper · ORCID
classification cs.AI
keywords LLMagentslearnersimulationprogrammingeducationTreeofThoughtknowledgetracingcognitivearchitecturecodemodificationpredictionpersonalizedtutoring
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 claims that the missing ingredient in programming-learning simulation is fine-grained, iterative code modification, and that an LLM-based agent can reproduce it. Concretely, CoderAgent predicts a student's next modification intention, the code location they will edit, the next code they will submit, and whether that submission is accepted, without needing large training corpora of learner responses. This matters because personalized programming tutoring—exercise recommendation, hints, and course design—is starved of high-quality learner data by cost, time, and privacy, while existing simulators mostly predict only right or wrong answers. A simulator that shows why, how, where, and what a learner changes could generate interpretable practice trajectories and support cold-start personalization.

What carries the argument

The Programming Tree of Thought (PTOT) is the named mechanism that carries the argument: it forces the agent to answer four questions before every edit—why to modify (root cause), how to modify (strategy), where to modify (code location), and what to modify (concrete replacement)—so that the generated edit is localized and traceable. PTOT is fed by the execution tools' compiler feedback and by short-term memory of the question and previous code, and it is constrained by a Reflection module that rejects edits beyond the student's profiled ability or inconsistent with their coding style. The ACT-R-inspired memory module, which separates programming knowledge from coding ability, supplies the student-specific profile that makes the simulated edits personal rather than generic.

What would settle it

Select a random sample of CoderAgent predictions from Tasks 1 and 2, have several human programming instructors independently judge the same matches that the GPT-4o-mini judge scores, and compute agreement between the human raters and between humans and the LLM judge. If human-model agreement is low while the reported ACC is high, or if human raters disagree with one another, the reported accuracy is an artifact of the self-judge rather than evidence of simulation fidelity.

Watch

Extended reading notes

Core claim

The paper's central claim is that an LLM agent can emulate the full iterative programming process of a human learner, not merely whether their next submission passes. In CoderAgent, each learner is represented by an ACT-R-inspired long-term memory of programming knowledge, coding ability, coding style, and common errors; the agent then uses the Programming Tree of Thought to decompose each debugging step into why the code must change, how to change it, where the change belongs, and what concrete edit to make. On the CodeNet and CSEDM datasets, the paper reports that CoderAgent beats the only comparable baseline (OKT) on modification intention, edit location, and next-code prediction, and also beats knowledge-tracing baselines on pass or fail prediction. The reported numbers include modification-intention accuracy around 0.37 to 0.45 depending on dataset and model, edit-location accuracy around 0.49 to 0.59, CodeBLEU near 0.59 to 0.77, and AUC near 0.54 to 0.55; a case study in the paper matches a student's actual order of fixes, resolving syntax errors before a semantic loop error.

Load-bearing premise

The whole accuracy story depends on GPT-4o-mini being a trustworthy judge of whether a predicted edit intention and location really match what the student did, and no human check confirms that judge.

Editorial extensions

If this is right

  • Personalized tutoring systems can be trained and evaluated on simulated practice trajectories instead of waiting for large, privacy-restricted collections of real learner submissions.
  • Because the agent produces an interpretable why-how-where-what trace for every edit, educators and systems can inspect a learner's debugging path and target interventions at specific misconceptions.
  • The same simulation can expand small real datasets: course instructors can use generated submissions to discover mistake-prone points and build more comprehensive test cases for assignments.
  • A single framework now covers both fine-grained iteration (intention, location, next code) and outcome prediction, replacing pipelines that need separate models for each.
  • The cold-start property means new learners with only a small history can be simulated, enabling personalization before sufficient data accumulates.

Reading between the lines

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

  • A natural next step not reported in the paper is to validate the GPT-4o-mini judge against human raters on a subset of Task 1 and Task 2 predictions; without that, the reported accuracy conflates simulation fidelity with judge self-consistency.
  • The PTOT decomposition is not obviously limited to programming: any task with localized, feedback-driven revision, such as essay editing or spreadsheet debugging, could be simulated with the same why-how-where-what loop.
  • The paper's 'without real data' claim actually assumes that a learner profile is available from prior history; a fully cold-start student with no submissions would require a default profile, a regime the current evaluation does not isolate.
  • A downstream test the paper does not run is to feed CoderAgent-generated trajectories into a recommender or hint system and measure whether students trained or evaluated on simulated data learn as well as they do with real data.
Share X Bluesky LinkedIn Reddit HN

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 CoderAgent, an LLM-based agent framework to simulate students' iterative programming practice. The framework combines an ACT-R-inspired memory module, a Programming Tree of Thought (PTOT) planning process, compiler tools, and a reflection module. The paper evaluates CoderAgent on two real-world datasets (CodeNet and CSEDM) across four tasks: predicting the next modification intention, the edit location, the next code submission, and the pass/fail outcome. It reports performance gains over several baselines and presents case studies and applications in mistake-prone point analysis and test case generation. The central claim is that CoderAgent achieves accurate and interpretable fine-grained simulation of student programming behavior without relying on extensive real data.

Significance. If the central claim were well supported, CoderAgent would be a valuable tool for generating synthetic learner data in programming education, addressing data scarcity and enabling personalized tutoring. The idea of decomposing debugging into why/how/where/what steps (PTOT) is a plausible and interpretable approach, and the paper makes code available. However, the current empirical evidence is not sufficient to establish the claimed accuracy of the fine-grained simulation, particularly because the metrics for the two central tasks rely on an unvalidated LLM judge, and the remaining evidence is either near-random or lacks crucial baselines.

major comments (5)
  1. [§4.1 (Evaluation)] The accuracy for Tasks 1 and 2 is computed by an LLM judge (GPT-4o-mini), which is the same model family as the CoderAgent core. No human-annotated validation, inter-annotator agreement, or judge prompt/rubric is reported. Because the judge and the generator share a model family, the reported ACC values (e.g., 0.3841 on CSEDM Task 1, 0.5324 on Task 2) may reflect the judge's agreement with its own generation style rather than genuine fidelity to student behavior. This is load-bearing because Tasks 1 and 2 are the only evidence for the central claim of capturing modification intentions and edit locations.
  2. [§4.1, Table 4 (Task 4)] The AUC values for Task 4 (0.535–0.552) are only slightly above the random baseline of 0.5, and the gain over the best baseline (PST, 0.526–0.527) is about 0.02. No error bars, confidence intervals, or significance tests are reported. Given the near-random performance, Task 4 provides little support for the claim of accurate simulation of pass/fail outcomes.
  3. [§3.2, Eq. (1)] The abstract and introduction claim that CoderAgent simulates 'without relying on real data,' yet Eq. (1) updates long-term memory using historical task data H_i^t, and §3.2 states that the memory is updated using historical data from students' prior coding tasks. This reliance on real submission histories contradicts the cold-start claim and needs to be clarified or reframed.
  4. [Table 3 (Task 3)] The CodeBLEU scores for Task 3 are not compared against a trivial baseline that simply copies the previous submission. Since student submissions in an iterative process are typically small edits, a copy-previous-code baseline is a natural reference; without it, the high CodeBLEU values (e.g., 0.758 on CSEDM) may overstate the simulation quality.
  5. [§3.4, §3.5] No ablation study is provided to isolate the contributions of PTOT, the Reflection module, or the Memory module. The interpretability claim is supported only by a single case study (§4.3). A comparison to a Chain-of-Thought-based alternative or an ablation of the reflection module is needed to justify the design choices and the claimed benefits.
minor comments (5)
  1. [§4.1] The use of an 80/10/10 train/validation/test split is unclear because CoderAgent is an in-context learning method with no explicit training; please specify how the split is used.
  2. [§4.1] The subset sizes sampled from CodeNet and CSEDM, and the student activity threshold, are not reported; these details are needed for reproducibility.
  3. [§3.4, Eq. (2)] The sentence 'where g applies planned modifications p_t to code segment s_t to generate s'_t' is duplicated verbatim; please remove the redundancy.
  4. [§4.4, Figure 3] The bar charts report counts from only 20 students with no error bars or significance tests; please either add statistical support or temper the claims about the application results.
  5. [Miscellaneous] The GitHub repository name 'USTChandsomeboy' is informal; consider using a more neutral name consistent with academic conventions.

Circularity Check

1 steps flagged · score 6.0 of 10

Fine-grained simulation claims (Tasks 1/2) are self-refereed: GPT-4o-mini both generates the predicted intentions/locations and judges their accuracy, so the reported ACC is a self-defined metric.

  1. self definitional [§4.1 Experimental Setup, Evaluation; §4.1 Methods (CoderAgent core)]
    "Task 1 and task 2 is utilized to evaluate the fine-grained precision of code iteration, assessing whether the system can accurately simulate what students think and do. We leverage LLMs (GPT-4o-mini) to assess the accuracy (ACC) of these two tasks. / We use GPT-4o(2024-11-20) and GPT-4o-mini(2024-07-18) as the CoderAgent core."

    CoderAgent(4o-mini) generates the predicted modification intention and edit location using GPT-4o-mini as its core, and the reported ACC for Tasks 1 and 2 is awarded by GPT-4o-mini, with no human annotations, inter-annotator agreement, or independent rubric described. 'Modification intention' is a latent construct inferred from code diffs; the only operational definition of accuracy provided is GPT-4o-mini's agreement, so the predictor and the judge come from the same model family. The paper's central fine-grained simulation claim ('achieves accurate simulations') therefore rests on a self-defined metric rather than on observable student behavior.

full rationale

The paper is not globally circular: Task 3 next-code prediction is evaluated by CodeBLEU against real test submissions, and Task 4 by AUC against actual AC labels, so those parts have external grounding. However, the paper's distinctive claim—fine-grained simulation of modification intentions and edit locations—is supported only by Tasks 1 and 2, whose accuracy is measured by GPT-4o-mini, the same model family that generates the predictions. No human validation, judge prompt, rubric, or inter-annotator agreement is reported, and the text does not specify how 'student actual behavior' is converted into ground-truth labels for these two tasks. Consequently, the reported ACC values (roughly 0.37–0.45 for Task 1 and 0.52–0.59 for Task 2) may reflect GPT-4o-mini's self-consistency rather than fidelity to real student cognition. This is a partial, metric-definition circularity rather than a full collapse of the derivation, so the score is 6.

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

The central claim rests on the assumption that LLM agents can faithfully simulate student programming behavior and that the chosen evaluation metrics capture fidelity. No free parameters in the sense of a fitted theory are introduced; the experimental choices (sampling, judge prompts) are unstated and could affect results. PTOT is a reasoning template, not a new entity with independent falsifiable predictions.

free parameters (3)
  • Dataset sampling subset size
    Subsets sampled from CodeNet and CSEDM due to API cost; sampling strategy not described (§4.1).
  • Student activity threshold
    Excluded students with insufficient submissions; threshold not specified (§4.1).
  • LLM judge prompt template
    Tasks 1 and 2 accuracy assessed by GPT-4o-mini prompts; prompts not given, so results depend on unstated judge settings (§4.1).
assumptions (4)
  • domain assumption ACT-R cognitive architecture models programming behavior as knowledge mastery plus coding ability.
    Invoked in §3.2 Memory Module to justify splitting memory into knowledge and ability; cited to Anderson & Lebiere 2014 and Berges et al. 2012 but assumed valid.
  • domain assumption LLMs can produce realistic student-like code edits via in-context learning.
    Core to the framework; §2 and §3 assume LLMs like GPT-4o can emulate human programming behavior, cited to recent LLM agent works.
  • domain assumption CodeBLEU and AUC are valid measures of simulation fidelity.
    Used in §4.1 Evaluation; CodeBLEU is a standard code metric, AUC for classification, both assumed appropriate.
  • ad hoc to paper GPT-4o-mini can reliably judge whether predicted modification intention/location matches student behavior.
    No validation of the judge is provided; this assumption is necessary for the task 1 and 2 accuracy results (§4.1).

how reviews work

0 comments
Cite this review

Pith. "Pith review of CoderAgent: Simulating Student Behavior for Personalized Programming Learning with Large Language Models." pith.science (2026). https://pith.science/paper/FUKIHQOD

@misc{pith2026250520642,
  author       = {Pith},
  title        = {Pith review of: CoderAgent: Simulating Student Behavior for Personalized Programming Learning with Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FUKIHQOD}},
  note         = {Machine review of arXiv:2505.20642}
}
read the original abstract

Personalized programming tutoring, such as exercise recommendation, can enhance learners' efficiency, motivation, and outcomes, which is increasingly important in modern digital education. However, the lack of sufficient and high-quality programming data, combined with the mismatch between offline evaluation and real-world learning, hinders the practical deployment of such systems. To address this challenge, many approaches attempt to simulate learner practice data, yet they often overlook the fine-grained, iterative nature of programming learning, resulting in a lack of interpretability and granularity. To fill this gap, we propose a LLM-based agent, CoderAgent, to simulate students' programming processes in a fine-grained manner without relying on real data. Specifically, we equip each human learner with an intelligent agent, the core of which lies in capturing the cognitive states of the human programming practice process. Inspired by ACT-R, a cognitive architecture framework, we design the structure of CoderAgent to align with human cognitive architecture by focusing on the mastery of programming knowledge and the application of coding ability. Recognizing the inherent patterns in multi-layered cognitive reasoning, we introduce the Programming Tree of Thought (PTOT), which breaks down the process into four steps: why, how, where, and what. This approach enables a detailed analysis of iterative problem-solving strategies. Finally, experimental evaluations on real-world datasets demonstrate that CoderAgent provides interpretable insights into learning trajectories and achieves accurate simulations, paving the way for personalized programming education.

Figures

Figures reproduced from arXiv: 2505.20642 by the authors.

Figure 1
Figure 1. The example of the programming practice process [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. CoderAgent Framework. (a) The overall pipeline of CoderAgent; (b) Long-term memory, containing knowledge, ability and style; [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Simulation results in programming applications [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

41 extracted references · 33 canonical work pages

  1. [1]

    Using large language models to simulate multiple humans and replicate human subject studies

    Gati V Aher, Rosa I Arriaga, and Adam Tauman Kalai. Using large language models to simulate multiple humans and replicate human subject studies. In International Conference on Machine Learning , pages 337--371. PMLR, 2023

    work page 2023

  2. [2]

    The atomic components of thought

    John R Anderson and Christian J Lebiere. The atomic components of thought . Psychology Press, 2014

    work page 2014

  3. [3]

    The gap between knowledge and ability

    Marc Berges, Andreas M \"u hling, and Peter Hubwieser. The gap between knowledge and ability. In Proceedings of the 12th Koli Calling international conference on computing education research , pages 126--134, 2012

    work page 2012

  4. [4]

    E-qgen: Educational lecture abstract-based question generation system

    Mao-Siang Chen and An-Zi Yen. E-qgen: Educational lecture abstract-based question generation system. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI-24 , pages 8631--8634. International Joint Conferences on Artificial Intelligence Organization, 8 2024. Demo Track

    work page 2024

  5. [5]

    Designing and implementing a case - based learning environment for enhancing ill - structured problem solving: classroom management problems for prospective teachers

    Insu Choi and Kyounghee Lee. Designing and implementing a case - based learning environment for enhancing ill - structured problem solving: classroom management problems for prospective teachers. Educational Technology Research and Development , 57(1):99--129, 2009

    work page 2009

  6. [6]

    Knowledge tracing: Modeling the acquisition of procedural knowledge

    Albert T Corbett and John R Anderson. Knowledge tracing: Modeling the acquisition of procedural knowledge. User modeling and user-adapted interaction , 4:253--278, 1994

    work page 1994

  7. [7]

    Codebert: A pre-trained model for programming and natural languages

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, et al. Codebert: A pre-trained model for programming and natural languages. arXiv preprint arXiv:2002.08155 , 2020

    arXiv 2002

  8. [8]

    Research on the learning experience of virtual simulation class experimental teaching and learning based on the perspective of nursing students

    Yazhuo Gao and Xuehua Zhu. Research on the learning experience of virtual simulation class experimental teaching and learning based on the perspective of nursing students. BMC nursing , 22(1):367, 2023

    work page 2023

Show all 41 references
  1. [9]

    Rcd: Relation map driven cognitive diagnosis for intelligent education systems

    Weibo Gao, Qi Liu, Zhenya Huang, Yu Yin, Haoyang Bi, Mu-Chun Wang, Jianhui Ma, Shijin Wang, and Yu Su. Rcd: Relation map driven cognitive diagnosis for intelligent education systems. In Proceedings of the 44th international ACM SIGIR conference on research and development in i...

    2021

  2. [10]

    Denoising programming knowledge tracing with a code graph-based tuning adaptor

    Weibo Gao, Qi Liu, Rui Li, Yuze Zhao, Hao Wang, Linan Yue, Fangzhou Yao, and Zheng Zhang. Denoising programming knowledge tracing with a code graph-based tuning adaptor. In Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V. 1 , pages 354--365, 2025

    2025

  3. [11]

    Agent4edu: Generating learner response data by generative agents for intelligent education systems

    Weibo Gao, Qi Liu, Linan Yue, Fangzhou Yao, Rui Lv, Zheng Zhang, Hao Wang, and Zhenya Huang. Agent4edu: Generating learner response data by generative agents for intelligent education systems. arXiv preprint arXiv:2501.10332 , 2025

    2025 arXiv

  4. [12]

    Social learning through interactions with other agents: A survey

    Dylan Hillier, Cheston Tan, and Jing Jiang. Social learning through interactions with other agents: A survey. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI-24 , pages 8067--8076. International Joint Conferences on Artificia...

    2024

  5. [13]

    Long short-term memory

    S Hochreiter. Long short-term memory. Neural Computation MIT-Press , 1997

    1997

  6. [14]

    An llm-enhanced agent-based simulation tool for information propagation

    Yuxuan Hu, Gemju Sherpa, Lan Zhang, Weihua Li, Quan Bai, Yijun Wang, and Xiaodan Wang. An llm-enhanced agent-based simulation tool for information propagation. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI-24 , pages 8679--...

    2024

  7. [15]

    Recommender ai agent: Integrating large language models for interactive recommendations

    Xu Huang, Jianxun Lian, Yuxuan Lei, Jing Yao, Defu Lian, and Xing Xie. Recommender ai agent: Integrating large language models for interactive recommendations. arXiv preprint arXiv:2308.16505 , 2023

    2023 arXiv

  8. [16]

    Pst: measuring skill proficiency in programming exercise process via programming skill tracing

    Ruixin Li, Yu Yin, Le Dai, Shuanghong Shen, Xin Lin, Yu Su, and Enhong Chen. Pst: measuring skill proficiency in programming exercise process via programming skill tracing. In Proceedings of the 45th International ACM SIGIR Conference on Research and Development in Information...

    2022

  9. [17]

    Llm-based multi-level knowledge generation for few-shot knowledge graph completion

    Qian Li, Zhuo Chen, Cheng Ji, Shiqi Jiang, and Jianxin Li. Llm-based multi-level knowledge generation for few-shot knowledge graph completion. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI-24 , pages 2135--2143. Internation...

    2024

  10. [18]

    Liang, T

    Y. Liang, T. Peng, Y. Pu, et al. Help-dkt: an interpretable cognitive model of how students learn programming based on deep knowledge tracing. Scientific Reports , 12:4012, 2022

    2022

  11. [19]

    Ekt: Exercise-aware knowledge tracing for student performance prediction

    Qi Liu, Zhenya Huang, Yu Yin, Enhong Chen, Hui Xiong, Yu Su, and Guoping Hu. Ekt: Exercise-aware knowledge tracing for student performance prediction. IEEE Trans. on Knowl. and Data Eng. , 33(1):100–115, 2021

    2021

  12. [20]

    A survey of knowledge tracing

    Qi Liu, Shuanghong Shen, Zhenya Huang, Enhong Chen, and Yonghe Zheng. A survey of knowledge tracing. CoRR , abs/2105.15106, 2021

    2021 arXiv

  13. [21]

    Open-ended knowledge tracing for computer science education

    Naiming Liu, Zichao Wang, Richard Baraniuk, and Andrew Lan. Open-ended knowledge tracing for computer science education. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing , 2022

    2022

  14. [22]

    An evaluation of the impact of automated programming hints on performance and learning

    Samiha Marwan, Joseph Jay Williams, and Thomas Price. An evaluation of the impact of automated programming hints on performance and learning. In Proceedings of the 2019 ACM Conference on International Computing Education Research , pages 61--70, 2019

    2019

  15. [23]

    Knowledge organization and skill differences in computer programmers

    Katherine B McKeithen, Judith S Reitman, Henry H Rueter, and Stephen C Hirtle. Knowledge organization and skill differences in computer programmers. Cognitive Psychology , 13(3):307--325, 1981

    1981

  16. [24]

    Generative agents: Interactive simulacra of human behavior

    Joon Sung Park, Joseph O'Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang, and Michael S Bernstein. Generative agents: Interactive simulacra of human behavior. In Proceedings of the 36th annual acm symposium on user interface software and technology , pages 1--22, 2023

    2023

  17. [25]

    Empowering personalized learning through a conversation-based tutoring system with student modeling

    Minju Park, Sojung Kim, Seunghyun Lee, Soonwoo Kwon, and Kyuseok Kim. Empowering personalized learning through a conversation-based tutoring system with student modeling. In Extended Abstracts of the CHI Conference on Human Factors in Computing Systems , pages 1--10, 2024

    2024

  18. [26]

    Deep knowledge tracing

    Chris Piech, Jonathan Bassen, Jonathan Huang, Surya Ganguli, Mehran Sahami, Leonidas J Guibas, and Jascha Sohl-Dickstein. Deep knowledge tracing. Advances in neural information processing systems , 28, 2015

    2015

  19. [27]

    Codenet: A large-scale ai for code dataset for learning a diversity of coding tasks

    Ruchir Puri, David S Kung, Geert Janssen, Wei Zhang, Giacomo Domeniconi, Vladimir Zolotov, Julian Dolby, Jie Chen, Mihir Choudhury, Lindsey Decker, et al. Codenet: A large-scale ai for code dataset for learning a diversity of coding tasks. arXiv preprint arXiv:2105.12655 , 2021

    2021 arXiv

  20. [28]

    Engineering education in the era of chatgpt: Promise and pitfalls of generative ai for education

    Junaid Qadir. Engineering education in the era of chatgpt: Promise and pitfalls of generative ai for education. In 2023 IEEE Global Engineering Education Conference (EDUCON) , pages 1--9. IEEE, 2023

    2023

  21. [29]

    Ethical considerations in ai and data science-addressing bias, privacy, and fairness

    Surendranadha Reddy Byrapu Reddy, Prabu Ravichandran, Srihari Maruthi, Mohan Raparthi, Praveen Thunki, and Sarath Babu Dodda. Ethical considerations in ai and data science-addressing bias, privacy, and fairness. Australian Journal of Machine Learning Research & Applications , ...

    2022

  22. [30]

    Codebleu: a method for automatic evaluation of code synthesis

    Shuo Ren, Daya Guo, Shuai Lu, Long Zhou, Shujie Liu, Duyu Tang, Neel Sundaresan, Ming Zhou, Ambrosio Blanco, and Shuai Ma. Codebleu: a method for automatic evaluation of code synthesis. arXiv preprint arXiv:2009.10297 , 2020

    2009 arXiv

  23. [31]

    Learning to represent student knowledge on programming exercises using deep learning

    Lisa Wang, Angela Sy, Larry Liu, and Chris Piech. Learning to represent student knowledge on programming exercises using deep learning. International Educational Data Mining Society , 2017

    2017

  24. [32]

    Llm-powered multi-agent framework for goal-oriented learning in intelligent tutoring system

    Tianfu Wang, Yi Zhan, Jianxun Lian, Zhengyu Hu, Nicholas Jing Yuan, Qi Zhang, Xing Xie, and Hui Xiong. Llm-powered multi-agent framework for goal-oriented learning in intelligent tutoring system. In ACM Web Conference , 2025

    2025

  25. [33]

    Chain-of-thought prompting elicits reasoning in large language models

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

    2022

  26. [34]

    Eduagent: Generative student agents in learning

    Songlin Xu, Xinyu Zhang, and Lianhui Qin. Eduagent: Generative student agents in learning. arXiv preprint arXiv:2404.07963 , 2024

    2024 arXiv

  27. [35]

    Do llms overcome shortcut learning? an evaluation of shortcut challenges in large language models

    Yu Yuan, Lili Zhao, Kai Zhang, Guangting Zheng, and Qi Liu. Do llms overcome shortcut learning? an evaluation of shortcut challenges in large language models. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing , pages 12188--12200, 2024

    2024

  28. [36]

    Towards accurate and fair cognitive diagnosis via monotonic data augmentation

    Zheng Zhang, Wei Song, Qi Liu, Qingyang Mao, Yiyan Wang, Weibo Gao, Zhenya Huang, Shijin Wang, and Enhong Chen. Towards accurate and fair cognitive diagnosis via monotonic data augmentation. In The Thirty-eighth Annual Conference on Neural Information Processing Systems

  29. [37]

    Understanding and improving fairness in cognitive diagnosis

    Zheng Zhang, Le Wu, Qi Liu, Jiayu Liu, Zhenya Huang, Yu Yin, Yan Zhuang, Weibo Gao, and Enhong Chen. Understanding and improving fairness in cognitive diagnosis. Science China Information Sciences , 67(5):152106, 2024

    2024

  30. [38]

    Simulating student interactions with two-stage imitation learning for intelligent educational systems

    Guanhao Zhao, Zhenya Huang, Yan Zhuang, Jiayu Liu, Qi Liu, Zhiding Liu, Jinze Wu, and Enhong Chen. Simulating student interactions with two-stage imitation learning for intelligent educational systems. In Proceedings of the 32nd ACM International Conference on Information and ...

    2023

  31. [39]

    Large language model as a policy teacher for training reinforcement learning agents

    Zihao Zhou, Bin Hu, Chenyang Zhao, Pu Zhang, and Bin Liu. Large language model as a policy teacher for training reinforcement learning agents. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI-24 , pages 5671--5679. Internation...

    2024

  32. [40]

    Programming knowledge tracing: A comprehensive dataset and a new model

    Renyu Zhu, Dongxiang Zhang, Chengcheng Han, Ming Gaol, Xuesong Lu, Weining Qian, and Aoying Zhou. Programming knowledge tracing: A comprehensive dataset and a new model. In 2022 IEEE International Conference on Data Mining Workshops (ICDMW) , pages 298--307. IEEE, 2022

    2022

  33. [41]

    write newline

    " write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence '...

Pith tools

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