AIEd Knowledge BaseAIEd KB
On this page

Concept

CS Education

created 2026-08-09 · updated 2026-11-07

CS Education — computer science education is the most-researched STEM subfield in the knowledge base, benefiting from natural alignment between AI tools and programming tasks. Code generation, debugging assistance, and automated code review are its primary AI applications. Because students learn to build the very tools they use, CS education sits at the center of debates about AI literacy, curriculum redesign, agentic software engineering, and the boundary between genuine learning and over-reliance.

Questions to Consider

  • If AI can now write code that passes real programming exams, what should students still learn to do by hand — and what should the curriculum stop teaching?
  • Research found that higher trust in an AI coding assistant predicted WORSE ability to tell correct from misleading suggestions. How is trust different from appropriate reliance, and how would you teach the latter?
  • In student-AI co-programming, nearly 80% of interactions relied on non-learning strategies like outsourcing answers, and only about 1 in 9 showed deep epistemic engagement. Why does genuine learning rarely happen by default when AI is available?
  • A Learning by Teaching agent that was too competent undermined students' debugging practice. Would you deliberately make an AI tutor fallible — and if so, how?
  • As AI automates implementation, curricula are shifting from writing code to verifying and directing AI-generated artifacts. What new competencies does that demand, and what might get lost in the shift?
  • Students are building the very tools they use. How does being both builder and user of AI change what they should learn about its limits — and its ethics?

Introduction

AI in CS education

  • Code generation and completion: CS1 code review, DURA for CS2, and NL programming mistakes examine how students use AI for code generation and what they learn from it.

  • Conversational agents for novices (scoping review): Barzanji & Loitsch (2025) map 23 studies (2019–June 2024) of conversational agents for novice programmers, documenting a shift from rule-based chatbots to Large Language Models (LLMs)- and RAG (Retrieval-Augmented Generation)-based agents (with retrieval-augmented generation reducing hallucination) and personalized tutoring support (e.g., InfoBot, ProbSol-Bot, Lint Bot, Profe Alex). Notably, only 4 of 23 studies ground design in learning theory, and 17 of 23 prototypes are English-only despite most research originating outside English-speaking countries — flagging weak pedagogical grounding and an inclusivity gap for future CA design in introductory programming.

  • Debugging support: Debugging tools, human-AI debugging collaboration, and dyadic pair-programming modeling leverage AI for error identification and repair.

  • A live course deployment found hint length, not model choice, to be the actionable variable. Three consecutive deployments in an introductory web development course (o3-mini, GPT-5-mini and GPT-5.5 across 79,438, 83,374 and 10,420 logged submissions) associated hints with better immediate outcomes in several comparisons. Longer messages predicted worse next-submission correctness, more attempts and slower resubmission, and students who had received hints on earlier project steps solved the final step less often, at 95.6% against 98.1% (Mihaylova et al., 2026).

  • A browser-resident tool-augmented tutor is the architecture the field is converging on. A tool-augmented SLM design pairs a small fine-tuned planner (1B–7B) with four deterministic tools — code executor, test runner, documentation retriever, Knowledge Tracing module — behind a four-tier escalation policy (tools first, on-device SLM, consent-gated cloud LLM, instructor), shifting pedagogical control from the model to the auditable policy; a preliminary ~150M completion model reaches 10.97% HumanEval pass@1, above several 100M–150M code baselines (Suvernev et al. (2026)).

  • A small fine-tuned tutor can out-scaffold a larger general model. Fine-tuning Qwen2.5-Coder-7B-Instruct on 1,213 synthetic tutoring dialogues cut premature solution disclosure from 7.43% to 1.88% of tutor turns and raised stepwise scaffolding and debugging-question quality above GPT-4o's, though reliable pedagogical plan generation stayed the open problem (Kopytskyi et al. (2026)).

  • Automated assessment: Linux Bash grading, a large-scale 18-model grading comparison, and LLM intervention review evaluate automated code assessment. The security of that workflow is a separate question: Humble (2026) red-teamed a routine AI grading task and found that instructions hidden inside a submitted file raised a failing essay's grade with no visible warning, in 9 of 9 iterations for one strategy and 17 of 18 for another — evidence that grader robustness belongs on the Assessment Validity checklist alongside accuracy.

  • A one-sentence grader prompt can collapse an LLM, and fine-tuning repairs it. Habibullah et al. (2026) graded a practical computer vision exam (570 dual-graded students) under 171 configurations and a machine learning exam (1,038 students) under 162 more. A short "strict grader" preamble drove 14 of 17 open-weight models out of the graded band (MAE ≥ 8), with three stopping grading altogether, and the damage traced to two credit-withholding policy sentences whose direction did not transfer to the second exam (seven models improved). One LoRA adapter over roughly 3,900 pooled graded examples brought five small open models to parity with a human grader.

  • AI-generated learning media: Generated Animated Traces show that AI-generated visualizations can aid immediate learning but must be personalized — mid-engagement students experienced a performance decrement consistent with the expertise-reversal effect.

  • GenAI analogy critique as an instructional asset: Bernstein & Sibia (2026) ground GenAI analogy reception in CS2: ten students who had already completed CS2 audited GenAI-generated analogies for linked lists and recursion and rejected mappings that failed structural correspondence — an island-route analogy that mapped to a circular rather than a singly linked list, or a badminton rally offered for recursion despite having no guaranteed shrinking input, with one student proposing golf instead. The work argues that analogy critique is itself a check on concept understanding, making flawed AI analogies a usable instructional asset rather than a hazard to filter out, and recommends assigning them as objects to inspect and repair.

  • Misconception modeling: a taxonomy of conditionals/loops misconceptions gives automated systems a precise vocabulary for diagnosing novice errors.

  • Model-generated strategic misconceptions: Miličević et al. (2026) built SocraticTrap-CS around 35 concepts from the ACM/IEEE CS2023 curriculum — algorithms, programming languages, databases, networks and operating systems — and asked seven open-weight models for a fluent, authoritative explanation resting on a subtle error. Six of the seven produced an expert-confirmed strategic misconception for 91% or more of prompted concepts (221 of 241 segments, 91.7%), with no significant differences between CS domains; conceptual errors dominated (66.5% conceptual vs. 33.5% factual, and none purely logical), and both persuasiveness and error type varied by domain. The authors therefore recommend domain-sensitive countermeasures — reasoning-focused checks in programming-heavy courses, cross-referencing against protocol specifications in networking — and evaluation of Automated Question Generation and AI-authored explanations on pedagogical trustworthiness rather than correctness alone.

  • Authentic Assessment performance: Lepp & Kaimre (2026) show 2026 GenAI systems outscore the average student cohort on authentic introductory OOP assessments and frequently earn full marks on longer programming tasks, yet still struggle with interfaces, abstract classes, inheritance, and image-based questions — recurring error patterns instructors can exploit when designing assessments. A CS1 longitudinal study reinforces the capability side of that finding: Ye et al. (2026) measured frontier models at 98.93-99.99% on the labs against 76.37-88.03% for student submissions.

  • Repository activity is not what it used to be. Across 260 capstone team repositories (ten semesters, 2021-2025), end-of-semester codebases roughly tripled, from about 3.4 KLOC in 2021-2023 to about 10 KLOC in 2024-2025, with cyclomatic complexity and error-handling density rising while comment density stayed flat (Shakil, Brabrand & Denny (2026)). Later cohorts also committed more often and in greater volume with unchanged per-commit edit sizes, a development-rhythm shift project courses should weigh before treating repository activity as evidence of progress.

  • Predictive modeling for at-risk support: Zhang, Jeffries & Koprinska (2025) show that intrinsically interpretable decision trees trained on content-interaction log features accurately predict module-level progress in large-scale online programming courses (85–91% accuracy across four K-12 courses) and flag "No submission" dropout outcomes, giving educators a 7–8 day window to intervene with struggling and disengaged Learners before module deadlines — complementing the automated-grading and attrition-prediction work above.

  • Retrieval-augmented support for theoretical CS fits asynchronous study only. AlgoRAG answered all 179 instructor-authored exam questions within a 240-second timeout at a mean 38.0 seconds each, and its BLEU-4 of 0.0000 across the set is a property of n-gram matching on mathematical proofs rather than a system failure (Adhikari (2026)).

  • Adoption tracks the assignment, not the subfield. Across seven assignments and 211 students, Nizamani et al. (2026) measured LLM use from 89.6% in algorithms to 15.2% in software engineering, attributing the spread to assignment complexity, verifiability and scaffolding rather than to the subject itself.

  • Feedback can be staged so the diagnosis stays hidden. Riazi & Rooshenas (2026) separate an artifact-grounded diagnosis of a student's database schema from the workflow that releases it, with educators authoring the stages; across 383 episodes, 71.1% of feedback reached its target level.

Programming pedagogy: from blocks to embodied, game-based learning

Programming education spans introductory block-based programming to advanced software development, and increasingly grounds abstract code in concrete, observable outcomes.

  • Block-based visual programming: environments like Scratch and Blockly let beginners snap together graphical blocks rather than type text, eliminating syntax errors and making program structure visible — especially valuable for younger learners and for controlling educational robots. In the AI era they are increasingly combined with conversational AI agents (e.g., Micro:bit + MakeCode in teacher training, small-language-model tutors).
  • Embodied block programming: RoboBlockly Studio combines block-based programming with a conversational AI teaching agent and embodied robot execution, creating an iterative authoring–running–observing–revising loop that preserves learner Learner Agency.
  • Natural-language robot control: EduSim-LLM lets beginners control simulated robots through natural-language instructions, lowering the barrier to robot programming without requiring low-level code expertise.
  • Robotics and computational thinking: Valls i Pou links computational thinking to educational robotics in secondary STEAM curricula, and teacher-training research argues robotics and ML activities should be embedded in Teacher Education.
  • Game-based and gamified learning: A systematic review compares game-based learning (suited to informal settings) and gamification (suited to formal classrooms) in robotics education, which emphasizes introductory programming and modular kits.
  • Project-based robotics: Bots and Blocks teaches robotics programming through an agile, semester-spanning project, addressing the theory-practice gap in higher-ed.
  • LLM impact on learning outcomes: Jošt et al. (2024) and a meta-analysis of GenAI and programming learning examine whether AI-assisted tools help or undermine programming achievement.

Curriculum transformation in the AI era

The question "what should students still learn by hand?" now reshapes computing programs.

  • From implementation to verification: Reshaping Undergraduate CS Education argues that as GenAI automates implementation-level programming, debugging, and testing, curricula must shift toward understanding and verifying AI-generated artifacts, preserving system design, abstraction, and critical evaluation while de-emphasizing low-level implementation details. This aligns with AI Literacy frameworks that prize evaluation over generation.

  • Agentic software engineering as a discipline: ASE-26 formalizes directing agents rather than writing code — teaching auditability, context engineering, verification, multi-agent workflows, and AgentOps — and positions agentic AI competence as a structured, scaffolded curriculum rather than syntax mastery.

  • From production to judgment: comprehension debt and AASEE. Mahmoud (2026) argues the field should shift from a production-centered to a judgment-centered model, and extends comprehension debt — the deferred learning and maintenance cost when AI-assisted production outpaces a learner's ability to explain, test, modify, and justify the software — into an Assessment lens, grounded in 621 reflective diaries from 207 students. The review refines the AASEE framework into five non-linear integration levels crossed by four evidence obligations — explain, verify, modify, and account — and reports a conditional evidence base: a STEM meta-analysis with extreme heterogeneity (I² = 96.32%) loses its pooled benefit once publication bias is corrected, and syntheses of 76, 72, and 64 studies show short-term efficiency gains that do not transfer to unaided performance.

  • New pedagogies and assessment models: Test-Driven AI-Assisted Learning replaces lectures with self-directed AI-assisted study gated by weekly closed-book tests, preserving individual accountability while AI agents scale material production and marking under human oversight.

  • Oral examinations as the accountability mechanism. A project-based AI Engineering program ran second-semester students through seven two-week sprints with AI embedded in requirements, architecture, coding and testing, and made individual oral examinations mandatory after three runs showed artifacts alone no longer evidenced understanding; average missing ECTS fell from 25% to 3% (Rausch (2026)).

  • Teach the model's mechanics offline. A practitioner resource suite teaches the full LLM training→generation pipeline unplugged — hand-tallied n-gram grids and dice-based sampling, no programming or mathematics assumed — and reports delivery to roughly 400 participants, with engagement beginning only at the generation stage (Swift (2026)).

  • What predicts Vibe Coding success — and what to keep teaching: A preregistered CHI 2026 study (N=100) of pure "no-code" vibe-coding found that both computer-science achievement (r = .39) and written-communication proficiency (r = .29) independently predicted performance, with CS achievement remaining significant even after controlling for domain-general cognitive ability and contributing roughly twice the unique variance of writing skill. Because the environment hid generated code, CS knowledge could only help indirectly (problem decomposition, algorithmic thinking) — making the CS estimate a lower bound for AI-assisted workflows that also permit editing. The authors argue curricula should weigh written communication alongside CS fundamentals, rather than treating vibe coding as syntax mastery made obsolete.

AI literacy, agency, and the risk of over-reliance

Because programming is where AI assistance is most powerful, it is also where the failure modes are most visible.

  • Trust ≠ appropriate reliance: Trust and reliance on AI (Pitts et al.) find that higher trust in an AI assistant predicted worse discrimination between correct and misleading suggestions during Python Problem Solving — moderated by AI Literacy and need for cognition. Calibration, not confidence, is the goal.

  • Epistemic AI literacy: Wu (2026) shows that in student-AI co-programming, 78.8% of interactions relied on non-mastery-oriented aims and unreliable strategies (outsourcing, verification-seeking), with only 11.1% showing high epistemic engagement — genuine learning rarely emerges without deliberate design support.

  • AI inquiries are narrow and generation-patterned. Classifying 830 CS2 prompts against the Graesser taxonomy, Amoozadeh and Alipour (2026) found assertion, verification, and instrumental prompts dominated both sessions, and that first-generation students asked fewer questions and leaned on verification while continuing-generation peers used the AI as an active problem-solving partner.

  • Structural interventions against copy-paste over-reliance: Soft barriers for copying in AI-assisted programming evaluate lightweight design interventions (e.g., mechanisms that discourage blind copy-paste of AI output) and find they can reduce over-reliance without blocking AI assistance — evidence that the over-reliance risk in CS education is amenable to instructional-design fixes, not just learner-education or bans.

  • Teachable agents and productive practice: Learning-by-teaching with ChatGPT improved knowledge gains and code quality but undermined error-correction practice because the agent is too competent — a design lesson: make agents deliberately fallible so debugging is preserved.

  • Assistance governance: a scoping review of 90 systems introduces the PEA framework (Policy, Enforcement, Authority) for bounding and controlling LLM assistance — a comparative vocabulary for designing Scaffolding that limits over-reliance.

  • Governance fit, not strictness. Dickey (2026) proposes a six-dimension governance profile — pedagogical grounding, AI instructional authority, human accountability, learner agency, context boundaries, and evaluation visibility — and shows across seven in-house tools and four published programming systems that the same model can distribute authority and accountability very differently; what predicts responsible scale is governance fit to the instructional function, not how strict the tool is.

  • Behavioral context for adaptive AI tutoring: Barron et al. (2026) present TutorTrace, a dataset and pipeline that makes learners' behavioral context computable in real time from IDE telemetry in AI-assisted Python courses (N=480). It derives a taxonomy of activity before, between, and across AI queries, and can classify whether an upcoming query reflects guided or dependent Help-Seeking (AUROC=.717) and predict imminent queries (AUROC=.726); behavior-aware prompts reduced no-independent-work query intervals from 50.0% to 20.7% in a preliminary evaluation. This shows how behavioral telemetry can make AI programming tutors adaptive to learners' actual effort, not just their explicit requests.

  • The duality of building what you use: CS students' unique position creates both meta-cognitive awareness of AI limitations and real risk of Over-Reliance on AI-generated code. Code review interviews and critical engagement studies address this tension directly.

  • Agentic coding and comprehension in team PBL: Tanaka et al. (2026) introduced Spec-Driven Development with AI agents into an undergraduate software-engineering project course and found that implementation throughput (added LOC) rose across 2022-2025 while heavy AI use coincided with code-comprehension dips that only recovered after one-on-one instructor checks - direct evidence that throughput gains do not guarantee understanding, and that over-reliance in AI-assisted coding is amenable to instructional monitoring.

  • Continuance, not adoption, is where GenAI's value is decided. A PRISMA review of 45 studies (2023–2025) finds improved code generation and debugging alongside unchanged conceptual depth, and argues that continued use depends on calibrated Trust, verification skill, and institutional guidance rather than perceived usefulness (Yalwa et al., 2026).

Equity, culture, and who gets into computing

  • Broadening participation: SuaCode documents motivations for smartphone-based coding among African students (fewer than 1% of secondary-school leavers have fundamental coding skills), informing accessible AI-supported MOOCs for low-resource contexts.
  • Neurodivergence and collaboration: Neurodivergent computing students report discomfort with ambiguous collaboration structures; structured assignments, smaller consistent teams, and explicit roles improve Accessibility — design lessons for the AI tools entering computing classrooms.
  • Culture shapes perceived ethics: Canadian vs. South Korean computing students judged identical AI-assisted coding practices differently despite functionally identical policies — policy harmonization does not produce perception harmonization, an Academic Integrity and Equity concern.
  • Collaboration transparency: Graf et al. find that partners' misaligned beliefs about each other's AI use predict lower project scores, especially for lower-performing students — transparency mechanisms (disclosures, shared logs) may be needed in collaborative programming.

Ethics education and the workforce

Connections

CS education connects to Computational Thinking, STEM Education, Automated Grading, Prompt Engineering, AI Literacy, Agentic AI, Curriculum Design, Human AI Collaboration, Higher Education, K-12, and Workplace Learning. Its closest applied neighbour is Information Technology Education: CS education takes the program and the algorithm as its object, whereas IT education takes the deployed organizational system and the practitioner's judgment about it — which is why the two fields debate different AI harms, whether code generation erodes programming skill against whether AI troubleshooting erodes diagnostic skill, and ask different questions of their graduates, whether they can build a system against whether they can govern the systems they administer. It is the domain where AIED tools are both used and built, making it a testbed for Intelligent Tutoring, Robots in Education, Collaborative Learning, Game-Based Learning, and the risks of Over-Reliance.

A 72-study synthesis and the VIE framework. Kumar, Wongsirichot and Nanthaamornphong (2026) reviewed the empirical literature on generative AI in computing and programming education (January 2022 – April 2026, 72 studies, 33 venues) and foreground exactly the structural feature that makes the discipline distinctive: the AI generates the assessable artifact itself, so using the tool, learning the skill and being assessed collapse into one keystroke. Their synthesis of 14 themes finds the field's most replicated effect — short-term efficiency and completion gains (36 studies) — is also its most misleading: those gains do not transfer to unaided performance (21 studies), and prior knowledge moderates whether assistance becomes durable skill or a crutch. Detection research is thin (3 studies) while course redesign is comparatively well evidenced (25 studies), and the review consolidates the corpus into three interdependent design requirements — Verification, Implementation and Equity — where critical engagement with AI output must be a graded, observable component of student work rather than an aspiration left to student discretion (Scaffolding, Assessment Validity).

Implications for computing instructors

  • Design assessments AI cannot coast through. Exploit GenAI's recurring failure patterns (interfaces, abstract classes, inheritance, image-based tasks) instead of banning tools outright — GenAI systems still struggle there.

  • Autogradable take-home assignments offered no completion resistance. Kaltchenko & Tiwana (2026) ran 50 ChatGPT sessions per Qiskit assignment and all 150 artifacts executed and passed the grader, because personalization varied parameters rather than task structure; the remedy is direct assessment of understanding — supervised modification or oral defense.

  • Calibrate trust, don't just build it. Trust-reliance research shows higher trust predicted worse discrimination of misleading AI suggestions; teach verification and critical evaluation, moderated by AI literacy and need for cognition.

  • Keep debugging and productive struggle alive. Choose tools or deliberately fallible agents (learning-by-teaching) that preserve error-correction practice, and personalize AI-generated media to avoid expertise-reversal effects (expertise-reversal).

  • Govern AI assistance explicitly. Define policy, enforcement, and authority for LLM support (PEA) rather than leaving boundaries implicit.

  • Shift curricula toward verification and agent direction. As GenAI automates implementation, teach understanding/verifying AI artifacts (reshape curricula) and structured agentic-software-engineering skills (ASE-26).

  • Structure collaboration for all learners. Smaller consistent teams, explicit roles, and AI-use transparency support neurodivergent students and fair collaboration, especially where misaligned AI-use beliefs lower project scores.

  • LLM-adaptive explanations of programming errors (2026): A crowdsourced study (N=103) found LLM-rewritten error messages improve readability, but objective debugging performance depends on matching explanation style (pragmatic vs contingent) to programmer skill — a scaffolding insight for AI-assisted programming education (Beyond the Traceback: Using LLMs for Adaptive Explanations of Programming Errors).

  • Oversight is about fitness, not correctness (2026): Coding 962 student-AI turns from 145 first-year software engineering students, Shakiba and Chaffey (2026) found 74.4% of interventions named fitness problems against 16.9% naming correctness, and 51.0% of responses modified the output rather than the prompt.

  • "Agreement on code means the grader reads the code." The benchmark's two instructor raters agreed at 0.815 on C++ answers: four models exceeded them with an interval above 100% of that ceiling and fourteen fell below, down to 33%. On the same code task, a note asking for full marks raised Qwen3 235B's grade by 83.2% of the scale, and seven models across the battery credited blank answers, so a grading pass over student code needs failure tests beside the agreement number.

  • "The effect is the same at every stage of a course." It grew with the work: on 60 complete Java programs graded on a 14-level rubric, the label's effect was 2.8 times its short-answer size on GPT-4.1-mini and 2.4 times on Qwen, though only 0.4 times on Gemini. Task and rubric are part of what the effect measures, so a size validated on short answers does not transfer to programs.

Common Misconceptions

  • "Students pair-programming with AI are learning to program." In student-AI co-programming, nearly 80% of interactions relied on non-learning strategies like outsourcing answers, and only about 1 in 9 showed deep epistemic engagement. The dominant pattern is transacting for output.
  • "Conversational agents for novices are grounded in learning theory." Only 4 of 23 studies ground design in learning theory, so most of the evidence base documents what a system did without a theory of why it should work.
  • "The tooling literature reflects the field's global distribution." 17 of 23 prototypes are English-only despite most research originating outside English-speaking contexts. The prototypes serve a narrower population than the research does.

Connected Concepts

Connected Articles

Connected Resources

  • LiaScript
    An open Markdown dialect that turns a plain text file into an interactive course in the browser, with quizzes and runnable code, plus a multi-agent assistant for building courses with it.
  • Code Viva
    A free browser tool that runs a written, timed version of an oral code defense for every student in a programming course, proposing scores with quoted evidence for the instructor to approve.

Metadata

DisciplineStem Education, Cs Education
LevelHigher Ed, K 12
Technologies and techniquesGenerative AI, Large Language Models (LLMs), Prompt Engineering
Assessment and measurementAutomated Assessment
Foundations of AI in educationAI Literacy, Computational Thinking
SourceHistoryEditChat

Embed this page

Copy the code below to embed this page in a learning management system or other website. The embedded version shows only the page content — it hides the site header, navigation, and footer.