{"id":"560fe815-edd4-43ae-ae09-b1e6ce66afcb","arxiv_id":"2501.10091","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"A controlled study of 37 programming students finds that most who used a chatbot requested full code solutions and repeatedly relayed error messages back to it, evidence for over-reliance on generative AI in learning.","lead":"During a monitored lab exercise, 37 programming students were given access to ChatGPT while solving a code comprehension task that ChatGPT could not solve directly. Most of the 23 who used the chatbot eventually asked it to generate full solutions, and many got stuck in cycles of wrong code and fix requests.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Productivity-decrease claim rests on a task deliberately unsolvable by the chatbot; the paper's own data show no significant slowdown among successful completers, so the abstract's generalization is unsupported.","rationale":"I considered three candidate concerns: (1) small self-selected sample, (2) reactivity from monitoring, and (3) the task-difficulty artifact behind the productivity claim. The sample-size and reactivity concerns are real but are acknowledged in Section 4.3.1 and partly mitigated by the observation of 'unethical' copy-paste behavior. The most load-bearing issue is the productivity conclusion, because it is the abstract's final and most general claim, and it is contradicted by the paper's own controlled comparison: no significant difference in time to correct solution. The longer total duration for chatbot users is explained by the failure loop, which is manufactured by selecting a task that GPT-3.5 cannot solve. Thus the evidence supports 'decreased agency' (students delegate and copy) but not 'decreased productivity' in any general sense. The paper's related work even cites studies showing time savings with GenAI (e.g., Berrezueta-Guzman and Krusche). A conditional acceptance with a required softening of the productivity sentence, or a reanalysis of the P2 subset, would settle whether the strong claim is justified. The paper deserves credit for transparent reporting, public data, and manual labeling with good inter-rater agreement; the delegation finding is solid, but the productivity claim overreaches the measured variables.","tokens_in":24673,"tokens_out":10776,"duration_ms":105592,"concrete_test":"Re-analyze the public interaction logs, focusing on the 13 P2 generations (where the bot was 76.9% correct): check whether the 'incorrect submission -> Codegen prompt -> incorrect close-match submission' cycle occurs following successful generations. If the cycle appears only for P1 (where the bot fails) and not for P2, then the 'vicious cycle' and the attendant productivity-decrease claim are artifacts of the unsolvable task. As a stronger check, run a matched replication with a standard course exercise that the deployed model solves correctly and compare completion times; if chatbot users are not slower (or are faster), the abstract's productivity claim should be removed.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The abstract concludes that 'concerns about potential decrease in programmers' agency and productivity with Generative AI are justified.' The agency component is supported by the delegation evidence (54.3% Copy All, 62% similarity claim), but the productivity component is not. The only productivity-relevant measure is session duration, which was significantly longer for chatbot users overall (26:15 vs 14:36, t=3.3, p=0.003), yet the paper explicitly states that 'when comparing the duration only among completed attempts, the difference is not significant (t=1.9, p>0.05).' The longer duration is therefore driven by participants who failed, and the failure loop is a direct consequence of the experimental task being engineered to be unsolvable by GPT-3.5: only 8.8% of 80 generated solutions for P1 were correct. The paper's own RQ1 shows that GPT-4 solves the large majority of course exercises, so in ordinary coursework the 'vicious cycle' would not occur and students might complete tasks faster, not slower. Consequently, the productivity-decrease generalization is an artifact of the adversarial task selection and the specific weak model, not a robust finding. The paper's caveat in Section 4.3.2 that only a single complex exercise was tested does not repair the abstract's unconditional productivity claim.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper investigates how programming students use generative AI tools in a monitored experimental setting. The authors first evaluate GPT-3.5 and GPT-4 on the exercises of an introductory programming course (RQ1), then conduct a controlled experiment in which 37 students solve a code comprehension and authoring exercise while having access to a ChatGPT-like chatbot (RQ2, RQ3). The task was deliberately designed to be unsolvable by GPT-3.5. The paper reports that among the 23 students who used the chatbot, a majority (73.9%) eventually submitted a Solve prompt, that 54.3% of submissions after chatbot interactions were semantically identical to generated code (Copy All), and that in 62% of cases with generations the modified submission was more similar to the generated code than to the previous submission. Students who reported regular GenAI use submitted relatively more Codegen prompts. The abstract concludes that concerns about decreased agency and productivity are justified. The paper discusses implications for assessment and education.","tokens_in":24936,"tokens_out":5215,"duration_ms":44067,"significance":"If the findings hold, the paper provides a valuable fine-grained behavioral account of how novices delegate coding work to a chatbot. Its strengths include the monitored experimental design with recorded code changes, clipboard events, and chat logs; the manual labeling of prompts and code changes with reported inter-rater agreement; the use of sequence pattern mining to identify interaction patterns; and the public availability of the data. The 'vicious cycle' of submitting incorrect generated code and asking for fixes is a concrete, observable phenomenon that extends prior work on novice-Copilot interaction. However, the productivity generalization in the abstract is not supported by the paper's own data, and the regularity-usage correlation is marginal. The core delegation findings are robust enough to merit publication, but the overreach must be corrected.","major_comments":[{"comment":"The abstract and Section 6 conclude that 'concerns about potential decrease in programmers' agency and productivity with Generative AI are justified.' The agency part is supported by the delegation evidence (54.3% Copy All, 62% similarity), but the productivity part is not. The only productivity-relevant measure is session duration, which was significantly longer for chatbot users overall (26:15 vs 14:36, t=3.3, p=0.003), yet Section 3.2.2 states that 'when comparing the duration only among completed attempts, the difference is not significant (t=1.9, p>0.05).' The longer duration is driven by participants who failed, and the failure loop is a direct consequence of the experimental task being engineered to be unsolvable by GPT-3.5 (Section 2.2.2; only 8.8% of 80 generated P1 solutions were correct in Section 3.2.4). The paper's own RQ1 results show that GPT-4 solves the large majority of course exercises, so in ordinary coursework the 'vicious cycle' would not occur and students might complete tasks faster, not slower. The caveat in Section 4.3.2 that only a single complex exercise was tested does not repair the abstract's unconditional productivity claim.","section":"Abstract and Section 3.2.2"},{"comment":"The abstract states that 'those who self-reported using generative AI regularly were more likely to prompt the bot to generate a solution.' This is based on the category-level correlation between GenAI usage and Codegen vs. Support prompts (Kendall's tau=0.45, p=0.03 in Table 4). However, the individual Solve prompt correlation is not significant (tau=0.12, p=0.58), and the Fix correlation (tau=0.42, p=0.05) is not significant after the paper's own Bonferroni correction (alpha=0.01). The category-level result is thus driven by the combination of labels, and with multiple comparisons the evidence is thin. The conclusion in Section 4.1.1 that 'as students self-learn and gain experience with LLMs, they become more reliant on its code output' goes beyond what this correlation supports. Please temper the claim or present the category-level analysis with a clear multiplicity caveat.","section":"Section 3.2.3 / Table 4"}],"minor_comments":[{"comment":"The two panels in Figure 10 appear to be duplicated in the rendering, which makes it hard to compare the left and right results; please ensure the figure legend and panels are visually distinct.","section":"Figure 10"},{"comment":"The example for the Solve label, '[question text] How do I produce the NullPointerException here?', reads more like a question than a direct request for a full solution; consider aligning the example with the label definition.","section":"Table 1"},{"comment":"The sentence 'On average, each participant submitted 4.57 prompts (M = 2, σ = 5.96)' is confusing because 'on average' and 'M' are redundant; clarify that M is the median.","section":"Section 3.2.2"},{"comment":"The 90% similarity threshold is justified by manual review, but it would strengthen the paper to report the threshold's sensitivity (e.g., prevalence of close matches at 80% and 95%) given that the sequence-mining results depend on it.","section":"Section 3.3.1"},{"comment":"The anecdote about participant GCL includes direct quotes from the chat log; consider adding a note about consent for quoting individual participant messages.","section":"Section 4.2.1"}],"recommendation":"major_revision","confidential_remarks":"The paper presents a valuable dataset and a careful behavioral analysis, but the abstract overreaches on productivity. With the productivity claim removed or reworded, and the regular-usage correlation presented with appropriate caution, the paper would be acceptable for publication. The delegate-vs-productivity distinction is the key issue to address in the revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: the delegation story is real and worth citing; the productivity story is not supported by the authors' own numbers. The genuinely new stuff is the controlled setup with a task GPT-3.5 can't solve, the copy/paste tracing, and the sequence mining. The 73.9% of chatbot users who eventually sent a Solve prompt, the 54.3% Copy All submissions, and the 62% similarity-to-generated-code result give concrete behavioral detail to what prior work mostly described qualitatively. It's also a nice nuance that most students tried the problem themselves first and only delegated after repeated failures — that is not the same as upfront cheating.\n\nThe soft spot is the last sentence of the abstract. The only productivity-relevant measure is session duration, and the difference between chatbot users and non-users disappears when you compare only completed attempts. The longer sessions are driven by students stuck in the error-fix loop, which exists because the task was deliberately engineered to be unsolvable by the weak model. RQ1 shows GPT-4 solves most course exercises, so in ordinary coursework the loop would likely not occur. The paper's own Section 4.3.2 caveat about a single complex exercise doesn't repair the unconditional productivity claim. Agency concerns are supported; decreased productivity is not.\n\nOther weaknesses are minor and acknowledged: n=37 with 23 users, self-selection, monitored lab setting, single university/course. The similarity threshold and sequence-mining parameters are reasonable, and the inter-rater agreement is reported. Data availability is a plus. I'd send this to reviewers — the core observations should survive a revision that softens the productivity generalization and frames the study as an exploration of one adversarial task rather than typical coursework. Good paper for a reading group, especially for discussing how far you can push a conclusion from a deliberately hard task.","headline":"Solid behavioral evidence that novices default to code-generation prompts once they hit a wall, but the abstract's productivity claim outruns the data.","tokens_in":25437,"tokens_out":2162,"would_cite":true,"duration_ms":23941,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Most students who used ChatGPT ended up asking it to solve the task","keywords":["generative AI","programming education","student behavior","ChatGPT","code comprehension","over-reliance","prompt strategies","code reuse"],"falsifier":"A replication with unobtrusive logging of students' own ChatGPT use during real homework, or an immediate post-task test showing that students who requested full solutions could still explain and modify the code, would contradict the paper's conclusion that unguided access leads to uncritical over-reliance.","tokens_in":24475,"feed_emoji":"🤖","tokens_out":4475,"duration_ms":40281,"temperature":0.7,"pith_summary":"The paper reports an experiment in which 37 first-semester programming students solved a code-comprehension exercise with monitored access to a ChatGPT-like chatbot. The task was designed so ChatGPT could not reliably solve it, forcing students to read and reason about code. Of the 23 students who used the chatbot, most eventually asked it to generate a full solution, and only a minority used it to understand concepts or their own mistakes. The authors argue this pattern supports educator concerns about over-reliance: students often copied generated code, submitted it, and on failure fed the error back to the bot in a repeat loop, without stepping back to evaluate the output.","feed_headline":"Most students who used ChatGPT ended up asking it to solve the task","feed_subtitle":"In a monitored lab exercise, 62% of edited submissions moved closer to the bot's code than to the student's own last attempt.","key_machinery":"The experiment's load-bearing object is the comprehension task itself: a Java exercise about null dereferencing and short-circuit evaluation that the authors verified GPT-3.5 could not solve reliably, so any correct answer required the student to trace code and reason about object state. Around it, the study records every prompt, chatbot response, copy/paste event and submission; prompts are labelled as Codegen (Solve, Fix) or Support (Hint, Inform, Explain), and responses as Informs, Solves or Explains. Similarity between submissions and generated code is measured with the Ratcliff/Obershelp algorithm, and code diffs are manually labelled (Copy All, Idea, Syntax, Explanation, None). Sequence pattern mining then exposes the recurring loop of incorrect submission, code-generation prompt, paste, and another incorrect submission.","core_discovery":"The central discovery is that when novices are free to consult a generative AI assistant, the default behaviour is delegation rather than comprehension. Most students first attempted the exercise on their own and did not ask for code immediately, but once they hit a difficulty, a majority shifted to requesting a complete solution; none asked the chatbot to explain why their own solution was failing. Comparing submissions to generated code shows the bot's output reshaped students' work: in 62% of cases with a generation in between, the modified submission was more similar to the generated code than to the previous submission, and 54.3% of such submissions were semantically identical to generated code. Students who self-reported regular GenAI use were more likely to send code-generation prompts, suggesting that experience with these tools strengthens rather than corrects the delegation habit.","pith_inferences":["If the observed cycle generalizes beyond the lab, it predicts that repeated ChatGPT use could train students to outsource the debugging step entirely, making it harder for them to detect when the tool is wrong.","A testable extension would compare retention: students who relied on generated code might score worse on a delayed, no-AI comprehension test than students who solved the exercise independently.","The similarity measure used here suggests a cheap, scalable detector: a submission whose distance to a prior bot response is smaller than its distance to the student's own previous submission would flag likely delegation.","The chatbot's apologetic and confident tone may have kept students in the error-submission loop, so an experiment with a less reassuring bot could test whether trust calibration alone reduces over-reliance."],"forward_implications":["In courses where submissions are the only assessment, AI-generated code is nearly indistinguishable from a good student's work, so submission-based grading loses much of its diagnostic value.","Interview-like reviews and tutor code reviews become a more reliable check, because a student presenting generated code must be able to justify and correct it on the spot.","Teaching GenAI use explicitly, including its limitations and non-code strategies, may be more productive than banning it.","Students who already use GenAI regularly are more likely to delegate code generation, so early habits matter."],"supporting_citations":[{"why":"Documents instructor and student concerns about GenAI over-reliance and the 'blindly copying and pasting solutions' behaviour the experiment measures.","marker":"[Prather et al. 2023a]"},{"why":"Provides the comparison point for AI-generated code reuse in novices and the finding that tool use can hurt later unaided performance.","marker":"[Kazemitabaar et al. 2023]"},{"why":"Reports that solution generation is the most common prompting pattern among programming beginners, which this study corroborates.","marker":"[Mailach et al. 2025]"},{"why":"Shows ChatGPT can find nonexistent issues in code, supporting the paper's task design and the observation that students cannot easily judge generated output.","marker":"[Hellas et al. 2023]"},{"why":"Supplies the Ratcliff/Obershelp similarity measure used to compare submissions with generated code.","marker":"[Ratcliff and Metzener 1988]"},{"why":"Provides the NOSEP sequence pattern mining algorithm used to discover the recurring error-fix-submit loops.","marker":"[Wu et al. 2017b]"}],"fun_headline_variants":["Students trade coding for ChatGPT delegation","ChatGPT turns students into solution requesters","Generative AI fosters code delegation, not learning","Most students hand off coding tasks to ChatGPT","Study: AI assistance leads to blind solution copying"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The study assumes that students' behaviour in a monitored lab session, where they knew their actions were recorded and participation was voluntary, matches how they actually use ChatGPT in their coursework.","fun_headline_variants_meta":{"raw":{"variants":["Students trade coding for ChatGPT delegation","ChatGPT turns students into solution requesters","Generative AI fosters code delegation, not learning","Most students hand off coding tasks to ChatGPT","Study: AI assistance leads to blind solution copying"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000345,"raw_usage":{"total_tokens":1901,"prompt_tokens":959,"completion_tokens":942,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":575,"completion_tokens_details":{"reasoning_tokens":876}},"tokens_in":575,"tokens_out":942,"duration_ms":7916,"temperature":1.0,"reasoning_tokens":876,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T19:23:14.903137+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"A replication with unobtrusive logging of students' own ChatGPT use during real homework, or an immediate post-task test showing that students who requested full solutions could still explain and modify the code, would contradict the paper's conclusion that unguided access leads to uncritical over-reliance.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the Ratcliff/Obershelp similarity measure used to compare submissions with generated code."}],"review_version":1}