CodeEdu: Collaborative Coding Education
- CodeEdu is a multi-agent collaborative platform that redefines coding as both a literacy and a civic competence.
- It integrates diverse educational methodologies—from school curricula to notebook-based projects and language localization—to enhance algorithmic understanding.
- Empirical evaluations show significant improvements in coding performance and conceptual grasp across varied learner profiles and settings.
CodeEdu denotes, in one recent usage, a multi-agent collaborative platform for personalized coding education, and more broadly the surrounding literature suggests a family of code-centered educational practices that treat programming as literacy, disciplinary method, and civic competence. Across school curricula, higher education, unplugged activities, notebook-based modules, Git-based project pipelines, intelligent tutoring systems, and multimodal recognition tools, the recurrent premise is that learners should move from merely using digital tools to understanding and shaping the algorithmic processes that organize them (Zhao et al., 18 Jul 2025, Henda, 2017, Barba, 2019).
1. Conceptual scope
A central claim in the literature is that coding is not a narrow vocational skill but a form of literacy. “Teaching computer code at school” argues that code instruction shifts digital learning from simple tool use to understanding how tools are conceived and function internally; it also frames code as “less and less an exclusivity” of programmers, relevant across sciences, humanities, and arts, and tied to autonomy, emancipation, and citizenship in a world that “functions almost exclusively through algorithms and programmatic processes” (Henda, 2017). The same line of argument treats computer code as one more cultural code among many symbolic systems already taught in school—language, mathematics, music, and other rule-governed representational systems—so the pedagogical question becomes not whether learners should code, but what they should learn by coding and by which methods (Henda, 2017).
This school-centered argument is extended by work on lifelong “pensée informatique”, which places programming within a broader “littératie informatique” and a technocritical understanding of algorithms, data, programs, languages, and networks. That literature distinguishes learning programming itself from learning through programming, and ties both to equal opportunity, parity, and the reduction of the digital fracture; the intended audience is not only pupils, but also teachers, parents, professionals, and citizens more generally (Atlan et al., 2019). A plausible implication is that CodeEdu is not exhausted by formal CS instruction: it includes civic preparation for participation in digitally governed social, political, and economic life.
Language constitutes an additional dimension of access. “Human Languages in Source Code: Auto-Translation for Localized Instruction” shows that source code contains a human-language layer—identifiers, comments, commit messages, and documentation—and studies 2.9 million Java repositories to show that more than 100 human languages appear in Java projects. It then introduces CodeInternational and an interactive Karel reader translated into 100 spoken languages, positioning localization as an educational intervention rather than a peripheral convenience (Piech et al., 2019). This suggests that CodeEdu includes the linguistic localization of code artifacts, not only their algorithmic content.
2. Historical and theoretical foundations
The modern resurgence of coding education is repeatedly described as an “old/new” debate. The historical point of departure is the digital laboratories of the 1960s, followed by later shifts associated with GUIs, programmable everyday tools, macros, plug-ins, and the normalization of digital culture in schools (Henda, 2017). Contemporary arguments, however, are not merely technological; they are anchored in a well-developed genealogy of learning theory. The same literature explicitly connects code education to Locke’s experiential learning, Montessori’s “absorbing mind” and autodirected practical activity, Bachelard’s emphasis on error and epistemological rupture, Piagetian constructivism, and Vygotsky’s zone of proximal development (Henda, 2017).
Papert occupies a special place in this genealogy. Working between Piaget’s constructivism and AI, he created Logo as a medium in which children direct a turtle to draw shapes, debug artifacts, and learn by error. Later, Scratch, developed by the MIT Lifelong Kindergarten Group, translated many of the same constructivist and socio-constructivist commitments into a block-based environment for stories, games, and simulations (Henda, 2017). The Louisiana “Introduction to Computational Thinking” curriculum rearticulates this lineage in a text-based but algebraically structured setting through CodeWorld, a simplified variant of Haskell designed for 8th/9th graders taking Algebra I concurrently. There, computational thinking is treated not as vague general problem solving but as introspection, explicit representation, constructive reasoning, causal thinking, and “reasoning by proxy” through data representations (Alegre et al., 2019).
Constructionism also informs work outside conventional school software. EDUMING proposes learning by “playing” and “making” digital games: learners modify source code, assets, variables, and mechanics in GameMaker Studio 2, then share the resulting games through GX Games. The game is therefore not a closed artifact but a modifiable template, and the learning focus is defined by the user rather than fixed in advance (Pietrusky, 1 Apr 2025). At the youngest end of the spectrum, visual and unplugged lessons with smart toys such as Pallino Coding and Peg Code connect CT to physical colors, rows, counts, and Polybius-square-style encodings, explicitly drawing on Bebras and CS Unplugged (Capecchi et al., 2022). Together these lines of work situate CodeEdu within a stable theoretical tradition rather than a transient technology cycle.
3. Curricular models and learning progressions
A recurrent curricular pattern is staged progression. One school-oriented framework begins with “informatique débranchée” and playful visual interfaces in pre-school and early primary years; moves to ludic, block-based programming in primary school; introduces more explicit algorithmic discovery in lower secondary; and reaches formal computer science concepts such as algorithms, data structures, and complexity in upper secondary (Henda, 2017). The Louisiana ICT pathway operationalizes this principle as a full-year ninth-grade course: first-semester CodeWorld programming is restricted largely to expressions, variables, and functions, while second-semester work introduces lists, tuples, and higher-order functions, all embedded in graphics, charts, calculations, and models in space and time (Alegre et al., 2019).
At university level, contextualization becomes a dominant principle. “Engineers Code” rejects the decontextualized service-course model of programming for non-CS majors and instead embeds Python, NumPy, pandas, Matplotlib, SymPy, numerical ODEs, and linear algebra into engineering computations. Its reusable learning modules are organized as fully narrated Jupyter notebooks, approximately one credit-hour each, and cover data handling, descriptive statistics, linear regression with Earth temperature data, dynamics of change and motion, and vector spaces and linear algebra including eigenvalues, Markov chains, PageRank, and SVD-based image compression (Barba, 2019). In RL education, EduGym follows the same logic at a different technical level: each environment isolates a single RL challenge—exploration, partial observability, stochasticity, continuous action spaces, or model-based planning—and each interactive notebook explicitly connects equations and code (Moerland et al., 2023).
Other curricular strands emphasize form factor rather than discipline. “Using Code Snippets to Teach Programming Languages” argues for short, self-contained, single-purpose code snippets, high-quality prose and media, interactive terminals and questions, a final project, and explicit support mechanisms as the design elements of effective snippet-based instruction (Akingbade et al., 31 May 2025). Visual and unplugged coding lessons with smart toys use physical mosaics and colored pegs to teach sequencing, loops, algorithms, cryptography, and debugging without electronics (Capecchi et al., 2022). “Handwritten Code Recognition for Pen-and-Paper CS Education” defends paper-based programming as a way to reduce intimidation, lower cognitive load, and support settings with limited computer access, while still reconnecting handwritten programs to execution through OCR, indentation recognition, and multimodal LLMs (Islam et al., 2024). A plausible implication is that CodeEdu is not tied to one medium; it is defined more by the relation between code and learning than by whether code is typed, blocked, spoken, played, or handwritten.
4. Platforms, tools, and technical infrastructures
Representative systems in the literature span notebook ecosystems, classroom analytics, online judges, Git-based project pipelines, and LLM agent architectures (Barba, 2019, Suzuki et al., 2020, Petegem et al., 2022, Zhao et al., 18 Jul 2025, Schaus et al., 21 Jan 2026).
| System | Primary role | Technical substrate |
|---|---|---|
| Engineers Code | Contextualized engineering computation modules | Jupyter notebooks, Open edX, Jupyter Viewer, Jupyter Grader, Docker |
| ICT / CodeWorld | Ninth-grade CT curriculum | Web-based CodeWorld, simplified Haskell |
| ClassCode | Self-paced classroom tutorials and progress tracking | AngularJS, D3.js, Node.js, Koa.js, MongoDB, Redis, WebSocket |
| Dodona | Virtual co-teacher and automated assessment | Ruby on Rails, Dockerized judges, JSON API, LTI, IDE plugins |
| CodeEdu | Personalized multi-agent coding tutor | CrewAI, Planner/Researcher/Tutor/Programmer/Report Analyst, tool pool |
| ICLF | Immersive project-based pipeline | GitHub, GitHub Actions, private forks, JavaGrader, INGInious |
The notebook-first line is exemplified by Engineers Code, whose Open edX integrations dynamically pull content from public Jupyter notebooks and auto-grade notebook submissions via nbgrader inside Docker containers (Barba, 2019). Classroom-centered environments such as ClassCode instead integrate explanatory text, quick exercises, milestone problems, solution galleries, hints, discussion boards, and instructor dashboards inside a web-based system designed for synchronous teaching, self-paced progression, and in-situ intervention (Suzuki et al., 2020). Dodona extends this architecture toward a mature intelligent tutoring system: submissions are queued, judged inside Docker containers through pluggable judges, and rendered with structured feedback, analytics, and interoperability through SAML, OAuth, OpenID Connect, LTI 1.3, and IDE plugins (Petegem et al., 2022).
Recent work pushes CodeEdu further into orchestration and software engineering realism. The platform named “CodeEdu” introduces a five-agent architecture—Planner, Researcher, Tutor, Programmer, and Report Analyst—implemented with CrewAI and augmented by a tool pool that includes a web crawler, file I/O, a code interpreter, and a deep research engine. The workflow begins with personalized inquiries that create a user profile, then dynamically allocates agents for material generation, Q&A, code execution, debugging, and report generation (Zhao et al., 18 Jul 2025). ICLF moves in a different direction: it treats student programming as participation in a living Git project, with a hidden parent repository containing solutions, an intermediate stripped template repository produced by CI, and private student forks that can be updated throughout the semester without disrupting work. In its Java instantiation, JavaGrader extends JUnit 5 with annotations such as @Grade, @GradeFeedback, and @Forbid, and INGInious reconstructs grading projects by replacing student-visible tests with authoritative teacher versions in a jailed environment (Schaus et al., 21 Jan 2026).
Two additional infrastructural lines widen the input and media channels of CodeEdu. CodeSCAN contributes a dataset of 12,000 VS Code screenshots across 24 programming languages, 25 fonts, and more than 90 themes for IDE element detection, color-to-black-and-white conversion, and OCR in coding screencasts, thereby targeting search and reconstruction in video programming tutorials (Naumann et al., 2024). Handwritten-code recognition addresses pen-and-paper workflows by combining OCR, indentation reconstruction, and LLM post-correction, or alternatively a multimodal vision-LLM, to turn photographed handwritten code into executable Python (Islam et al., 2024). EDUMING, finally, relocates code education into game modification through GameMaker Studio 2, GML Code, GML Visual, and GX Games, making source-level changes part of the learning loop (Pietrusky, 1 Apr 2025).
5. Assessment, analytics, and empirical evidence
The empirical record is heterogeneous but substantial. In the Louisiana ICT pathway, participation rose from about 200 students and five teachers in 2017–2018, to 400 students in 2018–2019, and about 800 students in 11 schools in 2019–2020. Across 325 students with matched Conceptual Foundations of Coding tests, average scores increased from to , for 24 percentage points of growth, with a Wilcoxon signed rank result of ; all four conceptual categories improved with . At the same time, the Computing Attitude Survey shift was , and the course was widely described as hard without demotivating students (Alegre et al., 2019).
In higher education, Engineers Code reports more modest but still positive evidence. In Spring 2019, 48 students participated, 23 answered the survey, and self-rated preparedness for learning to code rose from 5.4 to 7.4 on a 0–10 scale, while agreement with “I plan to use coding in my career after graduation” rose from 6.2 to 7.3. In a seniors’ retrospective survey of 32 respondents from the original Fall 2017 cohort, 78% answered 5 and 19% answered 4 to the question “Do you find yourself using these computational tools in other courses later?” (Barba, 2019). EduGym’s evaluation is attitudinal rather than performance-based, but 86% of students and researchers surveyed considered it a useful tool for RL education (Moerland et al., 2023). ClassCode’s evaluation is smaller—nine students in a short JavaScript lecture plus an expert review by one instructor and three teaching assistants—but it yielded convergent qualitative support for self-paced tutorials, embedded exercises, and instructor-facing dashboards (Suzuki et al., 2020).
Platform-scale evidence is most extensive for Dodona. By September 2022 it had more than 36 thousand registered users across many educational and research institutes, including 15 thousand new users in the last year, over 11 million submissions, approximately 10,000 assignments and 10,000 reading activities, and use at more than 1,000 institutions (Petegem et al., 2022). In one Python course case study, 442 students produced 331,734 submitted solutions in a single term, approximately 750 per student, while 2,215 questions were asked through the integrated Q&A system (Petegem et al., 2022). Such telemetry supports both formative teaching decisions and educational data mining.
LLM-mediated CodeEdu introduces a newer evidential regime. The multi-agent CodeEdu platform was evaluated on 100 LeetCode problems with low-, medium-, and high-level GPT-4o-simulated students. Relative to a static single GPT-4o baseline, it improved coding performance by 96.5% in Pass and 65.7% in Recall, and improved the overall quality of learning materials by 17.3%, including 31.4% on Interactivity and 16.7% on Personalization (Zhao et al., 18 Jul 2025). The main caveat is that both students and evaluators were simulated LLMs rather than humans. At the media-recognition layer, handwritten-code recognition reduces OCR error from about 30% with state-of-the-art OCR to about 5% in the best modular configuration, while the end-to-end multimodal approach reaches about 6% with limited logical-fix hallucination (Islam et al., 2024). Even toy-centered work reports structured feedback: Pallino Coding lesson questionnaires yielded average teacher scores of 4 for ease of understanding the instructions, 4 for identifying steps in sequence, 4 for the understandability of the coding language, 3.5 for ease of reading, and 3.5 for the overall activity (Capecchi et al., 2022).
6. Debates, constraints, and future directions
Several controversies recur across the literature. One concerns age appropriateness and curricular overload. Critics cited in the school-coding debate argue that coding is too technical, too specialized, or too early for children, and that rapidly changing languages make instruction obsolete; the counterargument is that the educational target is not early professional specialization but procedural literacy, algorithmic thinking, and the capacity to understand and critique the software systems that structure everyday life (Henda, 2017). Another concerns linguistic access: if educational code is inseparable from English, then language itself becomes a hidden prerequisite for CS education; localization work therefore argues for bilingual or local-language support in identifiers, comments, and instructional text, while preserving a path into the English-dominated software ecosystem (Piech et al., 2019).
Equity and scale are equally prominent. French work on lifelong computational thinking stresses that neither teachers nor parents are systematically prepared for this domain and that a “continuum éducatif tout au long de la vie” is required for all citizens, girls and boys, adults and professionals, not only future specialists. Large-scale projects such as Class’Code demonstrate feasibility but also the heavy infrastructure and labor required to sustain open, hybrid training at national scale (Atlan et al., 2019). Platform builders encounter analogous tensions between openness and control. Dodona openly supports collaborative learning and even open-Internet exams, but couples this with plagiarism analysis tools such as Dolos and policy design; ICLF archives marked files and complete Git histories for later comparison and forensics (Petegem et al., 2022, Schaus et al., 21 Jan 2026).
A newer set of debates centers on LLM mediation. The multi-agent CodeEdu tutor currently lacks human user studies and a formal student model, and its evaluations are restricted to LeetCode-style problems with LLM-simulated learners (Zhao et al., 18 Jul 2025). Handwritten-code correction must explicitly suppress “logical fix hallucinations” so that transcription does not silently solve the learner’s problem (Islam et al., 2024). A likely next direction is tighter coupling between tutoring, validated exercise generation, and curriculum control. CodeEvo already synthesizes code-centric data through iterative interactions between a Coder and a Reviewer, using hybrid feedback that combines compiler determinism with agent-level evaluation; this suggests a future CodeEdu pipeline in which instruction generation, testing, difficulty adjustment, and quality control are all driven by interaction rather than by static heuristics (Sun et al., 25 Jul 2025).
At its broadest, CodeEdu names a transition in how programming education is conceived. Coding appears simultaneously as a school subject, an engineering literacy, a notebook medium for disciplinary thinking, a game-modification practice, a repository-centered software engineering workflow, a target for OCR and video understanding, and a substrate for personalized tutoring agents. The common direction is not the replacement of teachers or curricula by tools, but the progressive embedding of code into the epistemic, linguistic, and civic infrastructures of learning.